Java学习笔记--线程

从我第一篇Java学习笔记系列开始，到现在所写的程序全是单线程程序，也就是程序从main()进入到结束只有一个流程，有时候我们需要设计程序拥有多个流程，也就是我要说的多线程（multi-thread）程序。

---

线程简介

我们先来看一个龟兔赛跑的例子（单线程实现）：
题目要求：
设计一个龟兔赛跑游戏，赛程长度为10歩，每经过一秒，乌龟前进一步，兔子则可能前进两歩也有可能睡觉。

import static java.lang.System.out;public class TortoiseHareRace {    public static void main(String[] args){        boolean[] flags = {true, false};        int totalStep = 10;                  //总步数        int tortoiseStep = 0;                //乌龟步数        int hareStep = 0;                    //兔子步数        out.println("龟兔赛跑开始...");        while(tortoiseStep < totalStep && hareStep < totalStep){            tortoiseStep++;                  //乌龟步数加一            out.printf("乌龟跑了 %d 步...\n", tortoiseStep);            boolean isHareSleep = flags[((int) (Math.random()* 10))% 2];   //随机睡觉            if(isHareSleep){                out.println("兔子睡着了");            }else{                hareStep += 2;                out.printf("兔子跑了 %d 步...\n", hareStep);            }        }    }}

再来看看多线程是怎么实现的：

乌龟：

public class Tortoise implements Runnable {    private int totalstep;    private int step;    public Tortoise(int totalstep){        this.totalstep = totalstep;    }    @Override    public void run(){        while(step < totalstep){            step++;            System.out.printf("乌龟跑了 %d 歩\n", step);        }    }}

兔子：

public class Hare implements Runnable {    private boolean[] flags = {true, false};    private int totalstep;    private int step;    public Hare(int totalstep){        this.totalstep = totalstep;    }    public void run(){        while(step < totalstep){            boolean isHareSleep = flags[((int) (Math.random()* 10))% 2];            if(isHareSleep){                System.out.println("兔子睡着了");            }else{                step += 2;                System.out.printf("兔子跑了 %d 歩\n", step);            }        }    }}

Main函数：

public class TortoiseHareRace2 {    public static void main(String[] args){        Tortoise tortoise = new Tortoise(10);        Hare hare = new Hare(10);        Thread tortoisethread  = new Thread(tortoise);        Thread harethread = new Thread(hare);        tortoisethread.start();        harethread.start();    }}

从上面的代码中我们可以看到线程使用方面一些基本的语法，在这里我就不再赘述。
其实，在Java中我们想要在main()以外设计独立的流程，可以攥写操作类接口java.lang.Runnable，流程的进入点是run方法。

---

Thread与Runnable

一般来说，我们可以认为JVM是一台虚拟的计算机，（粗略认为）但他只安装了一颗成为主线程的CPU，可执行main()定义的执行流程，如果想为JVM加装CPU，就要创建Thread实例，要启动额外CPU就要调用Thread的start方法。额外CPU的执行流程进入点，可以定义在Runnable接口的run方法中。

除了将流程定义在Runnable的run方法中，我们还可以继承Thread类，重新定义run方法，我建议使用第一种方法，因为我们操作Runnable接口的好处就是比较有弹性，你的类还有机会继承其他类。若我们继承了Thread之后，那我们的类就只是一种Thread，一般我们为了直接利用Thread中定义的方法，才会选择继承Thread。

---

线程生命周期

Daemon线程

主线程会从main方法开始执行，知道main方法结束之后停止JVM。如果主线程中启动了额外的线程，默认会等待被启动的所有线程都执行完run方法才终止JVM。如果一个线程被标示为Daemon线程，在所有的非Daemon线程都结束时，JVM就会自动终止。

我们可以使用setDaemon方法来设定一个线程是否为Daemon线程，来看一个例子：

public class DaemonDemo {    public static void main(String[] args){        Thread thread = new Thread(){            public void run(){                while(true){                    System.out.println("Orz");                }            }        };        thread.setDaemon(true);   //把此线程定义为Daemon线程        thread.start();    }}

如果我们没有使用setDaemon设定为true，那么程序会不断的输出Orz而不终止。使用isDaemon方法可以判断这个线程是否为Daemon线程。
我们默认所有的Daemon线程产生的线程也是Daemon线程。

---

Thread基本状态图

在调用Thread实例start方法后，基本状态为可执行（Runnable），被阻断（Blocked），执行中（Running）。

实例化Thread并执行start方法之后，线程进入Runnable状态，此时线程尚未真正开始执行run方法，必须等待排班器（Scheduler）排入CPU执行，线程才会执行run方法，进入Running状态。线程看起来是同时执行，但实际上同一时间点上，一个CPU还是只能执行一个线程，只是CPU会不断切换线程，且切换的动作很快，所以看起来像是同时执行。

线程具有优先权，可以使用Thread的setPriority方法设定优先权，可设定值在1到10之间，默认是5，超出1到10的设定值会抛出IllegalArgumentException，数字越大优先权越高，排班器越优先排入CPU，如果优先权相同，则输流执行。

有几种状况会使线程进入Blocked，如调用Thread.sleep()，进入synchronized前竞争对象锁定的阻断，调用wait方法的阻断，等待输入输出完成。运用多线程，当某线程进入Blocked时，让另一线程排入CPU执行（成为Running），避免CPU空闲下来，经常是改进效能的方式之一。

线程因为输入/输出进入Blocked状态，在完成输入/输出之后，会回到Runnable状态，等待排班器排入执行（Running状态）。一个进入Blocked状态的线程，可以由另一个线程调用该线程的interrupt方法，让他离开Blocked状态。

举个例子来说，使用Thread.sleep()会使线程进入Blocked状态，现在有其他线程调用该线程的interrupt方法，会抛出InterruptedException异常对象，这是让线程醒过来的方式。来看一个简单的范例：

public class InterruptedDemo {    public static void main(String[] args){        Thread thread = new Thread(){            @Override            public void run(){                try{                    Thread.sleep(99999);                }catch (InterruptedException ex){                    System.out.println("我醒了");                }            }        };        thread.start();        thread.interrupt();       //主线程调用thread的interrupt()    }}

---

安插线程

如果A线程正在运行，流程中允许B线程加入，等到B线程执行完毕之后在继续A线程流程，可以使用join方法完成这个 需求。

当线程使用join方法加入至另一线程的时候，另一线程会等待被加入的线程完成工作，然后继续它的动作。来看一个例子：

public class JoinDemo {    public static void main(String[] args) throws InterruptedException{        out.println("Main thread 开始...");        Thread threadB = new Thread(() -> {            out.println("Thread B开始...");            for (int i = 0; i < 5; i++){                out.println("Thread B 执行...");            }            out.println("Thread B 结束...");        });        threadB.start();        threadB.join();          //将线程B加入主线程流程        out.println("Main thread 将结束...");    }}

有时候可能加入的线程处理太久，你不想无止境等待这个线程工作完毕，则可以在join()时指定时间，如join(10000)，着表示加入流程的线程至多可以处理10000毫秒，也就是10秒，如果加入的线程还没有执行完毕就不管他了，目前线程可继续执行原本的工作流程。

---

停止线程

线程完成run方法之后，就会进入Dead，进入Dead（或已经调用过start方法）的线程不可以再次调用start方法，否则会抛出IllegalThreadStateException。

Thread类上有定义stop方法，不过被标示为Deprecated，这表示这些API虽然有，但由于一些原因并没有删除它，所以写程序的时候是十分不建议使用这样的API，这样的API还有像线程的暂停，重启（suspend(), resume()）等，如果我们要停止线程或者是暂停，重启必须视需求操作，让线程跑完应有的流程，而非直接停止！

---

关于ThreadGroup

每个线程都属于某个线程组群。若在main方法中产生一个线程，该线程会属于main线程组。可以使用以下程序获得目前线程所属的线程群组名：

Thread.currentThread().getThreadGroup().getName();

每个线程产生时，如果没有规定所属群组，则归入产生该子线程的线程群组。线程一旦归入某个群组，就无法再更换。

我们可以使用java.lang.ThreadGroup类来管理群组中的线程。可以使用以下方式产生群组，并在产生线程时指定所属群组：

ThreadGroup group1 = new ThreadGroup("group1");ThreadGroup group2 = new ThreadGroup("group2");Thread thread1 = new Thread(group1, "group1's member");Thread thread2 = new Thread(group2, "group2's member");

ThreadGroup中的某些方法，可以对群组中的所有线程产生作用。例如，interrupt方法可以中断群组中的所有线程，setMaxPriority方法可以设定群组中所有线程的最大优先权。

如果想要一次取得群组中的所有线程，可以使用enumerate方法。

Thread[] threads = new Thread[threadGroup1.activeCount()];threadGroup1.enumerate(threads);

activeCount方法取得群组中的线程数量，enumerate方法要传入Thread数组，这会将线程对象设定至每个数组索引。

ThreadGroup中还有个uncaughtException方法，群组中某个线程发生异常儿未捕捉时，JVM会调用此方法进行处理。如果ThreadGroup还有父ThreadGroup，就会调用父ThreadGroup的uncaughtException方法，否则看看是否为ThreadDead实例。若是则什么都不做，若不时则调用异常的printStrackTrace方法。如果必须定义ThreadGroup中线程的异常处理行为，可以重新定义次方法，例如：

public class ThreadGroupDemo {    public static void main(String[] args){        ThreadGroup group  = new ThreadGroup("group") {            @Override            public void uncaughtException(Thread thread, Throwable throwable) {       //得到异常线程，异常信息                System.out.printf("%s: %s\n", thread.getName(), throwable.getMessage());            }        };        Thread thread = new Thread(group, () -> {            throw new RuntimeException("测试异常");        });        thread.start();    }}

uncaughtException方法的第一个参数可取得发生异常的线程实例，第二个参数可取的异常对象。

在JDK5之后，如果线程组之中的线程发生异常，uncaughtException方法处理顺序是：

• 如果ThreadGroup有父ThreadGroup，就会调用父ThreadGroup的uncaughtException方法；
• 否则看看Thread是否使用setUncaughtExceptionHandler方法设定Thread.UncaughtExceptionHandler实例，有的话就会调用其uncaughtException方法；
• 否则看看异常是否为ThreadDead实例，若是的话则什么都不做，若不是的话调用异常的printStrackTrace方法。

---

synchronized与volatile

如果一个类会使线程存取同一对象相同资源时因发竞速现象，我们就说这个类是不具备线程安全的类，具体的例子我不在贴出，有疑问的读者可以自行百度。

---

使用synchronized

每个对象都会有个内部锁定，或称为监控锁定。被标示为synchronized的区块将会被监控，任何线程要执行synchronized区块都必须先取得指定的对象锁定。如果线程A已经取得对象锁定开始执行synchronized区块，B线程也想执行synchronized区块，会因无法取得对象锁定而进入等待锁定的状态，直到A线程释放锁定，B线程才有机会取得锁定对象儿执行synchronized区块。

实际上在等待对象锁定的时候，线程也会进入Blocked状态。线程若因尝试执行synchronized区块而进入Blocked，在取得锁定之后，会先回到Runnable状态，等待CPU排班器排入Running状态。

在之前讨论的Collection与Map都未考虑线程安全，可以使用Collections的synchronizedCollection()，synchronizedList()，synchronizedSet()，synchronizedMap()等方法，这些方法会将传入的Collection，List，Set，Map操作对象打包，返回具线程安全的对象。例如我们如果经常对List进行添加和移除的工作：

List<String> list = new ArrayList<>();synchronized(list){    ...    list.add("...");}...synchronized(list){    ...    list.remove("...");}

那么我们可以这样简化：

List<String> list = Collection.synchronizedList(new ArrayList<String>());

在Java中的synchronized提供的是可重入同步，也就是线程取得某对象锁定之后，若执行的过程中又要执行synchronized，尝试取得锁定的对象来源又是同一个，可以直接执行。

因为线程无法取得锁定时会造成阻断，所以不正确的使用synchronized有可能造成效能低落，另一个问题则是死结。例如：有些资源在多线程下交叉使用，就有可能造成死结。来看一个例子：

class Resource{    private String name;    private int resource;    Resource(String name, int resource){        this.name = name;        this.resource = resource;    }    String getName(){        return name;    }    synchronized int doSome(){        return ++resource;    }    synchronized void cooperate(Resource resource){        resource.doSome();        System.out.printf("%s: 整合 %s 的资源\n", this.name, resource.getName());    }}public class DeadLockDemo {    public static void main(String[] args){        Resource resource1 = new Resource("resource1", 10);        Resource resource2 = new Resource("resource2", 20);        Thread thread1 = new Thread(() -> {            for(int i = 0; i < 10 ; i++){                resource1.cooperate(resource2);            }        });        Thread thread2 = new Thread(() -> {            for(int i = 0; i < 20 ; i++){                resource2.cooperate(resource1);            }        });        thread1.start();        thread2.start();    }}

上面的程序发生死结是几率问题。多次执行后会发现，又是程序可顺利执行完成，有时程序会整个停顿。

造成上面的原因在于，thread1调用resource1.corportate（resource2）时，thread1会取得resource1的锁定，若此时thread2也调用resource2.corportate（resource1），就会取得resource2的锁定，凑巧的是thread1现在打算运用穿入的resource2调用doSome()，那么它就会尝试取得resource2的锁定，但是现在resource2的锁定在thread2手上，所以thread1就会被阻塞，相同的，resource1被传入resource2的方法之中，那么现在thread2就会尝试取得resource1的锁定，但是resource1的锁定在thread1手上，所以thread2也会被阻塞，最后就造成死结的情况。

我们在程序设计中，应尽量避免死结的发生。

---

使用volatile

synchronized要求达到所标示区块的互斥性与可见性，互斥性是指synchronized区块同时间只能有一个线程，可见性是指线程离开synchronized区块后，另一线程接触到的就是上一线程改变后的对象状态。

对与可见性的要求可以使用volatile达到变量范围。在讨论变量的可见性之前，我们先来看一个例子：

class Variable1 {    static int i = 0, j = 0;    static void one(){        i++;        j++;    }    static void two(){        System.out.printf("i = %d, j = %d\n", i, j);    }}public class Variable1Test{    public static void main(String[] args){        Thread thread1 = new Thread(() -> {            while(true){                Variable1.one();            }        });        Thread thread2 = new Thread(() -> {            while(true){                Variable1.two();            }        });        thread1.start();        thread2.start();    }}

在这个程序运行之后有可能出现j远大于i的结果。当thread2调用Variable1.two()取得i值之后，有可能切换thread1不断执行Variable1.one()多次，在切回thread2，就有可能发生这种情况。

我们可以像之前那样给one，two方法上标示synchronized，这样每次thread1调用one时，thread2就必须等待thread1释放锁定，才能调用two，thread2调用two时，thread1就必须等待thread2释放锁定，才能调用one。这样的确可以解决问题，但是当我们调用one时，其他线程就不能调用two，反之亦然。这样会看到执行速度明显变慢。

对于为何j会大于i，这和线程的“快取”有关，在这里不详细描述，要阻止这种情况的发生，我们可以在变量上声明volatile，表示变量是不稳定的，易变的，但即使这样，也只是提高了i，j相等的几率。被标示为volatile的变量不允许线程快取。实际上，如果我们要保证i，j相等的话，就要使用synchronized。

---

等待与通知

wait()，notify()，notifyAll()是Object定义的方法，可以通过这三个方法控制线程释放对象的锁定，或者通知线程参与锁定竞争。

在线程执行synchronized范围的程序代码期间，若调用锁定对象的wait方法，线程会释放对象锁定，并进入对象等待集合而处于阻断状态，其他线程可以竞争对象锁定。

放在等待集合的线程不会参与CPU排班，wait（）可以指定等待时间，时间到了之后线程会再次加入排班，如果指定时间0或不指定，则线程会持续等待，直到被中断（调用interrupt()）或是告知(notify())可以参与排班。

被竞争锁定的对象调用notify方法时，会从对象等待集合中随机通知一个线程加入排班，如果调用notifyAll方法，所有等待集合中的线程都会被通知参与排班。

线程调用对象wait方法时，会先让出synchronized区块的使用权并等待通知，或是等待指定时间，直到被notify方法或时间到时，（取得对象锁定之后）在从调用wait()处开始执行。

来举一个生产者，店员，消费者之间的例子，消费者每次生产一个int整数交给店员：

public class Producer implements Runnable{    private Clerk clerk;    public Producer(Clerk clerk){        this.clerk = clerk;    }    public void run(){        System.out.println("生产者开始生产整数... ...");        for(int product = 1; product <= 10; product++){            try{                clerk.setProduct(product);        //将产品交给店员            }catch (InterruptedException ex){                throw new RuntimeException(ex);            }        }    }}

程序中使用for循环生产1~10的整数，Clerk代表店员，可通过setProduct方法将生产的整数交给店员。

消费者从店员处取走int整数：

public class Consumer implements Runnable {    private Clerk clerk;    public Consumer(Clerk clerk){        this.clerk = clerk;    }    public void run(){        System.out.println("消费者开始消耗整数... ...");        for(int i = 1; i <= 10; i++){            try{                clerk.getProduct();        //从店员处取走产品            }catch (InterruptedException ex){                throw new RuntimeException(ex);            }        }    }}

程序中使用for循环来消费10次整数，可通过Clerk的getProduct方法，从店员处取走整数。

店员一次只能持有一个int整数，必须尽到要求等待与通知的职责：

public class Clerk {    private int product = -1;    public synchronized void setProduct(int product) throws InterruptedException{        waitIfFull();       //看看店员有没有空间收产品，没有的话就稍后        this.product = product;        System.out.printf("生产者设定 %d \n", this.product);        notify();         //通知等待中的线程（消费者）    }    private synchronized void waitIfFull() throws InterruptedException{        while(this.product != -1){         //店员由产品，没有空间            wait();        }    }    public synchronized int getProduct() throws InterruptedException{        waitIfEmpty();              //看看店员有没有货，没有的话就稍后        int p = this.product;        this.product = -1;           //表示货物被取走        System.out.printf("消费者取走 %d \n", p);        notify();                  //通知等待集合中的线程（生产者）        return p;    }    private synchronized void waitIfEmpty() throws InterruptedException{        while(this.product == -1){            wait();              }    }}

因为线程有可能在未经notify方法，interrupt方法或逾时情况下私自苏醒，所以wait方法一定要在条件式成立的循环中执行。

用以下程序示范生产者，消费者，店员：

public class ProducerConsumerDemo {    public static void main(String[] args){        Clerk clerk = new Clerk();        new Thread(new Producer(clerk)).start();        new Thread(new Consumer(clerk)).start();    }}

程序的运行结果希望大家自己能够尝试一下。