多线程——java实现多线程的方式

迷南。 2022-07-14 13:15 320阅读 0赞

**1、线程和进程**  
要理解多线程，我们必须首先弄清楚线程和进程的概念。在上一篇博文总已经较为详细的介绍过，本篇博文只做总结。

进程就是运行的程序，每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。

线程是程序执行的最小单位，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

线程和进程可以分为五个阶段：创建、就绪、运行、阻塞、终止。  
多进程是指操作系统能同时运行多个任务（程序）。  
多线程是指在同一程序中有多个顺序流在执行。

**2、Java线程的五种基本状态**

关于Java中线程的生命周期，首先看一下下面这张较为经典的图：

![这里写图片描述][SouthEast]

上图中基本上囊括了Java中多线程各重要知识点。主要包括：

**新建状态（New）**：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

**就绪状态（Runnable）**：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

**运行状态（Running）**：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

**阻塞状态（Blocked）**：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

（1）等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

（2）同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

（3）其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

**死亡状态（Dead）**：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

**3、Java多线程实现方式**

Java多线程实现方式主要有三种：继承Thread类、实现Runnable接口和使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，最后一种是带返回值的。

**3.1 继承Thread类实现多线程**  
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

import org.testng.annotations.Test;
    
    /** * 使用继承Thread类方式实现 * new一个thread或者写个thread子类，覆盖它的run方法。(new 一个thread并覆盖run方法实际上是匿名内部类的一种方式) * 继承Thread类，重写该类的run()方法 * * * 使用Thread类模拟3个售票窗口共同卖10张火车票的程序 * * 没有共享数据，每个线程各卖10张火车票 * */
    
    public class ThreadTest { 
        @Test
        public  void main(){
    
    // //1、第一种实现方法
    // //不共享数据，各自卖各自的，共30
    // for(int i = 0; i < 3; i++) { 
    // System.out.println("---------------" + i + "---------");
    // new Thread() { 
    // @Override
    // public void run() { 
    // int tickets = 10;
    // while (tickets > 0) { 
    // System.out.println(this.getName() + "卖出第【" + tickets-- + "】张火车票");
    // }
    // }
    // }.start();
    // }
    
    
            //2、第一种实现方法
            //2.1 不共享数据，各自卖各自的，共30
    // for(int i = 0; i < 3; i++){ 
    // System.out.println(Thread.currentThread().getName() + "--------" + i);
    // //创建一个新的线程 myThread 此线程进入新建状态
    // Thread myThread = new MyThread();
    // //调用start()方法使得线程进入就绪状态
    // //此时此线程并不一定会马上得以执行，这取决于CPU调度时机
    // //CPU调度就绪状态中的哪个线程具有一定的随机性
    // myThread.start();
    //
    // //new Thread(new MyThread()).start();
    // }
    
            // 1.2 不共享数据，各自卖各自的，共30
            new MyThread().start();
            new MyThread().start();
            new MyThread().start();
        }
    
        public class MyThread extends Thread{ 
            private  int tickets = 10;//每个线程都拥有10张票
    
            // run()方法的方法体代表了线程需要完成的任务，称之为线程执行体
            @Override
            public void run() {
                while(tickets > 0){
                    System.out.println(this.getName() + ": 卖出第【" + tickets-- + "】张火车票");
                }
            }
        }
    }

结果：

Thread-0: 卖出第【10】张火车票
    Thread-0: 卖出第【9】张火车票
    Thread-0: 卖出第【8】张火车票
    Thread-0: 卖出第【7】张火车票
    Thread-0: 卖出第【6】张火车票
    Thread-1: 卖出第【10】张火车票
    Thread-2: 卖出第【10】张火车票
    Thread-1: 卖出第【9】张火车票
    Thread-0: 卖出第【5】张火车票
    Thread-1: 卖出第【8】张火车票
    Thread-2: 卖出第【9】张火车票
    Thread-1: 卖出第【7】张火车票
    Thread-0: 卖出第【4】张火车票
    Thread-1: 卖出第【6】张火车票
    Thread-2: 卖出第【8】张火车票
    Thread-1: 卖出第【5】张火车票
    Thread-1: 卖出第【4】张火车票
    Thread-1: 卖出第【3】张火车票
    Thread-0: 卖出第【3】张火车票
    Thread-0: 卖出第【2】张火车票
    Thread-0: 卖出第【1】张火车票
    Thread-1: 卖出第【2】张火车票
    Thread-2: 卖出第【7】张火车票
    Thread-1: 卖出第【1】张火车票
    Thread-2: 卖出第【6】张火车票
    Thread-2: 卖出第【5】张火车票
    Thread-2: 卖出第【4】张火车票
    Thread-2: 卖出第【3】张火车票
    Thread-2: 卖出第【2】张火车票
    Thread-2: 卖出第【1】张火车票

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

从结果可以看到，每个线程分别对应10张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。**但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。**

**可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。**

**3.2 通过实现Runnable接口来创建多线程**  
实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。例如：

public class RunableTest { 
    
        private static int tickets = 10;//每个线程都拥有10张票
    
        public static void main(String[] args) {
    
            // 1、第一种方法
    // for(int i = 0; i < 3; i++) { 
    // System.out.println(Thread.currentThread().getName());
    // new Thread(new Runnable() { 
    //
    // @Override
    // public void run() { 
    // while (tickets > 0) { 
    // System.out.println(Thread.currentThread().getName() + ": 卖出第【" + tickets-- + "】张火车票");
    // }
    // }
    // }).start();
    // }
    
            //2、第二种方法
            for(int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName());
                // 创建一个Runnable实现类的对象
                Runnable myRunnable = new MyThread();
                // 将myRunnable作为Thread target创建新的线程
                Thread thread = new Thread(myRunnable);
                // 调用start()方法使得线程进入就绪状态
                thread.start();
               // new Thread(new ThreadTest.MyThread()).start();
            }
    
            //1.2
    // Runnable runnable = new MyThread();
    // new Thread(runnable).start();
    // new Thread(runnable).start();
    // new Thread(runnable).start();
    
        }
    
        public static class MyThread implements Runnable{ 
            public void run() {
                while(tickets > 0){
                    System.out.println(Thread.currentThread().getName() + ": 卖出第【" + tickets-- + "】张火车票");
                }
            }
        }
    }

结果：

Thread-0: 卖出第【10】张火车票
    Thread-0: 卖出第【8】张火车票
    Thread-1: 卖出第【9】张火车票
    Thread-1: 卖出第【5】张火车票
    Thread-1: 卖出第【4】张火车票
    Thread-1: 卖出第【3】张火车票
    Thread-1: 卖出第【2】张火车票
    Thread-1: 卖出第【1】张火车票
    Thread-0: 卖出第【6】张火车票
    Thread-2: 卖出第【7】张火车票

上面的程序中，创建了三个线程，每个线程调用的是同一个MyThread对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。**程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。**

**我们可以看出，通过实现Runnable接口，我们实现了多个线程去处理同一个资源。我们只能创建一个资源对象，但要创建多个线程去处理这同一个资源对象，并且每个线程上所运行的是相同的程序代码。**

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的。实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。

**3.3 3、使用ExecutorService、Callable、Future实现有返回结果的多线程**  
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问[http://www.javaeye.com/topic/366591][http_www.javaeye.com_topic_366591] ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：

import java.util.concurrent.*;
    import java.util.Date;
    import java.util.List;
    import java.util.ArrayList;
    
    /** * 有返回值的线程 */
    @SuppressWarnings("unchecked")
    public class Test { 
        public static void main(String[] args) throws ExecutionException,
            InterruptedException {
           System.out.println("----程序开始运行----");
           Date date1 = new Date();
    
           int taskSize = 5;
           // 创建一个线程池
           ExecutorService pool = Executors.newFixedThreadPool(taskSize);
           // 创建多个有返回值的任务
           List<Future> list = new ArrayList<Future>();
           for (int i = 0; i < taskSize; i++) {
            Callable c = new MyCallable(i + " ");
            // 执行任务并获取Future对象
            Future f = pool.submit(c);
            // System.out.println(">>>" + f.get().toString());
            list.add(f);
           }
           // 关闭线程池
           pool.shutdown();
    
           // 获取所有并发任务的运行结果
           for (Future f : list) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            System.out.println(">>>" + f.get().toString());
           }
    
           Date date2 = new Date();
           System.out.println("----程序结束运行----，程序运行时间【"
             + (date2.getTime() - date1.getTime()) + "毫秒】");
        }
        }
    
        class MyCallable implements Callable<Object> {
        private String taskNum;
    
        MyCallable(String taskNum) {
           this.taskNum = taskNum;
        }
    
        public Object call() throws Exception {
           System.out.println(">>>" + taskNum + "任务启动");
           Date dateTmp1 = new Date();
           Thread.sleep(1000);
           Date dateTmp2 = new Date();
           long time = dateTmp2.getTime() - dateTmp1.getTime();
           System.out.println(">>>" + taskNum + "任务终止");
           return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
        }
    }

代码说明：  
上述代码中**Executors类**，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

**public static ExecutorService newFixedThreadPool(int nThreads)** 创建固定数目线程的线程池。

**public static ExecutorService newCachedThreadPool()**创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

**public static ExecutorService newSingleThreadExecutor()** 创建一个单线程化的Executor。

**public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)** 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

**ExecutoreService**提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。

**4、继承Thread类和实现Runable接口比较**

**4.1 为什么Java要提供继承Thread类和实现Runable接口来实现多线程线程**

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类。这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享。

**4.2 实现Runnable接口相对于继承Thread类好处**

（1）**适合多个相同程序代码的线程去处理同一资源的情况**，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

（2）**可以避免由于Java的单继承特性带来的局限**。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

（3）**有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的**。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

值得注意的是：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM就是在操作系统中启动了一个进程。

[SouthEast]: /images/20220714/0cefe5aa49144ac287808a2b8845b483.png
[http_www.javaeye.com_topic_366591]: http://www.javaeye.com/topic/366591