java多线程 一:创建线程与实现多线程

文章出处：https://www.jianshu.com/p/ba24b782d5ca

文章对应视频出处：https://developer.aliyun.com/course/1012?spm=5176.10731542.0.0.6ef2d290hxQ4g0

继承Thead类实现多线程

  Java里面有一个java.lang.Thread的程序类，那么一个只要继承了此类就表示这个类为我们线程的主体类，但是并不是说这个类就可以实现多线程处理，因为还需要覆写Thread类中提供的一个run()方法，而这个方法就属于线程的主方法。
范例：多线程主体类

class MyThread extends Thread {//线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s运行.i = %s \n", this.title, i);
        }
    }

多线程要执行的功能都应该在run()方法中进行定义。
  需要说明的是：在正常情况下，如果想使用一个类中的方法，那么肯定要产生实例化对象，而后去调用类中提供的方法，但是run()方法是不能够直接被调用的，因为这里面牵扯到操作系统资源调度问题，所以要想启动多线程必须使用start()方法完成。
范例：多线程启动

public class ThreadDemo {
    public static void main(String[] args) {
        new MyThread("线程A").start();
        new MyThread("线程B").start();
        new MyThread("线程C").start();
    }
}

通过此时的调用你可以发现，虽然调用了start()方法，但是最终执行的是run()方法，并且所有的线程对象都是交替执行的。
  疑问：为什么多线程的启动不直接使用run()方法而必须使用Thread类中的start()方法呢？如果要想清楚这个问题，最好的做法是查看一下start()方法的实现操作，可以直接通过源代码进行观察。

   public synchronized void start() {
        if (threadStatus != 0) //判断线程的状态
            throw new IllegalThreadStateException();//抛出一个异常
        group.add(this);
        boolean started = false;
        try {
            start0();//在start()方法中调用了start0()
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    private native void start0();//只定义了方法名称，但没有实现

 发现start()方法里面会抛出一个IllegalThreadStateException异常类对象，但是整个程序中并没有使用throws或者是明确的try..catch处理，因为该异常一定是RuntimeException的子类，每一个线程类的对象只允许启动一次，如果重复启动则抛出IllegalThreadStateException异常，例如：下面的代码就会抛出异常。

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt=  new MyThread("线程A");
        mt.start();
        mt.start();//重复进行了线程的启动
    }
}

Exception in thread "main" java.lang.IllegalThreadStateException

 

在Java程序执行的过程之中，考虑到对于不同层次开发者的需求，所以其支持有本地的操作系统函数调用，而这项技术就被称为JNI(Java Native Inteface)技术，但是Java开发过程中并不推荐这样使用，利用这项技术可以使用一些操作系统提供的底层函数，进行一些特处理，而在Thread类中提供的start0()就表示需要将此方法依赖于不同的操作系统实现。

 

  任何情况下，只要定义了多线程，多线程的启动永远只有一种方案：Thread类中的start()方法。

基于Runnable接口实现多线程

  虽然可以通过Thread类的继承来实现多线程的定义，但是在Java程序中对于继承永远都是存在单继承的局限的，所以在Java中又提供第二种多线程的主体定义结构形式：实现java.lang.Runnable接口，此接口定义如下：

@FunctionalInterface //从JDK1.8引入Lambda表达式后就变为了函数式的接口
public interface Runnable{
    public void run();
}

范例：通过Runnable实现多线程主体类

class MyThread implements Runnable {//线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s运行.i = %s \n", this.title, i);
        }
    }
}

  但是由于此时不再继承Thread父类了，那么对于此时的MyThread类中也就不再支持有start()这个继承的方法，可是如果不用start()方法是无法进行多线程启动的，那么这个时候就需要去观察一下Thread类所提供的构造方法。

       构造方法：public Thread​(Runnable target);
       范例：启动多线程

public class ThreadDemo {
    public static void main(String[] args) {
        Thread threadA=new Thread(new MyThread("线程对象A"));
        Thread threadB=new Thread(new MyThread("线程对象B"));
        Thread threadC=new Thread(new MyThread("线程对象C"));
        threadA.start();//启动多线程
        threadB.start();//启动多线程
        threadC.start();//启动多线程
    }
}

这个时候的多线程实现中可以发现，由于只是实现了Runnable接口对象，所以此时线程主体类就不再有单继承局限，这样的设计才是一个标准型的设计。
  可以发现从JDK1.8开始，Runnable接口使用了函数式接口定义，所以也可以直接使用Lambda表达式进行线程类实现。
范例：利用Lambda实现多线程定

public class ThreadDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 3; i++) {
            String title = "线程对象" + i;
//            Runnable run = () -> {
//                for (int j = 0; j < 10; j++) {
//                    System.out.printf("%s运行.j = %s \n", title, j);
//                }
//            };
//            new Thread(run).start();
            new Thread(() -> {
                for (int j = 0; j < 10; j++) {
                    System.out.printf("%s运行.j = %s \n", title, j);
                }
            }).start();
        }
    }
}

 在以后的开发之中对于多线程的实现，优先考虑的就是Runnable接口实现，并且通过Thread类启动多线程。

Thread与Runnable关系

  经过一些列的分析之后可以发现，在多线程的实现过程之中已经有了两种做法：Thread类、Runnable接口，如果从代码本身来讲，肯定是用Runnable是最方便的，因为其可以避免单继承的局限，同事也可以更好的进行功能的扩充。
  但是从结构上也需要来观察Thread和Runnable的联系，打开Thead的定义：

public class Thread extends Object implements Runnable {}

  发现Thread类也是Runnable接口的子类，所以继承Thread类时覆写的还是Runnable接口的run()，于是此时观察一下程序的类结构

class MyThread implements Runnable {//线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s运行.i = %s \n", this.title, i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Thread threadA=new Thread(new MyThread("线程对象A"));
        Thread threadB=new Thread(new MyThread("线程对象B"));
        Thread threadC=new Thread(new MyThread("线程对象C"));
        threadA.start();//启动多线程
        threadB.start();//启动多线程
        threadC.start();//启动多线程
    }
}

 

多线程的设计之中，使用了代理设计模式的结构，用户自定义的线程主体只是负责项目核心的实现，而所有辅助实现全部由Thread类处理。
  在进行Thread启动多线程的时候调用的是start()方法，而后找到的是run()方法，但通过Thread类的构造方法传递了一个Runnable接口对象时，那么该接口对象将被Thread类中的target属性所保存，在start()方法执行时会调用Thread中的run()方法，而这个run()方法会去调用Runnable接口子类被覆写过的run()方法。
  多线程开发的本质实质上是在于多个线程可以进行同一资源的抢占，那么Thread主要描述的是线程，而资源的描述是通过Runnable完成的。

范例：利用卖票程序来实现多个线程的资源并发访问

class MyThread implements Runnable {//线程的主体类
    private int ticket = 5;
    @Override
    public void run() {//线程的主体方法
        for (int i = 0; i < 100; i++) {
            if (this.ticket > 0)
                System.out.printf("卖票，ticket = %s \n", this.ticket--);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();//第一个线程启动
        new Thread(mt).start();//第二个线程启动
        new Thread(mt).start();//第三个线程启动
    }
}

通过内存分析图来分析本程序的执行结构。

 

Callable实现多线程

  从最传统的开发来说，如果要进行多线程的实现肯定依靠Runnable，但是Runnable接口有一个缺点，当Runnable执行完成后无法获取一个返回值，所以从JDK1.5后提出了一个新的线程实现接口：java.util.concurrent.Callable接口，首先来观察这个接口的定义：

@FunctionalInterface
public interface Callable<V>{
    public V call() throws Exception;
}

 

  可以发现Callable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型，这样的好处在于避免向下转型所带来的的安全隐患。

范例：使用Callable实现多线程处理

class MyThread implements Callable<String> {//线程的主体类
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("*********** 线程、i = " + i);
        }
        return "线程执行完毕。";
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> task = new FutureTask(new MyThread());
        new Thread(task).start();
        System.out.println("【线程返回数据】" + task.get());
    }
}

 

线程运行状态

  对于多线程的开发而言，编写程序的过程之中总是按照：定义线程主体类，然后通过Thread类进行线程的启动，但是并不意味着你调用了start()方法，线程就已经开始运行了，因为整体的线程处理有自己的一套运行的状态。

1、任何一个线程的对象都应该使用Thread类进行封装，所以线程的启动使用的是start()，但是启动的时候实际上若干个线程都将进入到一种就绪状态，现在并没有执行；
       2、进入到就绪状态后就需要等待进行资源调度，当某一个线程调度成功之后则进入到运行状态(run()方法)，但是所有的线程不可能一直持续执行下去，中间需要产生一些暂停的状态，例如：某个线程执行一段时间之后就将需要让出资源，而后这个线程就将进入到阻塞状态，随后重新回归到就绪状态。
       3、当run()方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时就可以直接进入到停止状态。