---

参考资料：《Java高并发程序设计》

---

1.线程的基本操作

1.新建线程

1.继承Thread，重写run方法

 new Thread() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
 }.start();

2.实现Runnable接口，以参数的形式传给Thread的构造方法

new Thread(()-> System.out.println(Thread.currentThread().getName())).start();

2.终止线程

1.被废弃的方法：stop()

• 废弃的原因：stop()方法太过于暴力，强行把执行到一半的线程终止，并且立即释放这个线程所持有的 锁，这可能会引起 数据不一致 的问题。

2.正确的做法：让程序正常执行完毕自然退出

• 如果线程的主体是一个while循环，可以通过设置 标记变量 ，并在每次开始循环时检查该变量，来判断是否需要通过 break; 来退出循环。需要注意的是标记变量需要通过 volatile 关键字保证可见性。

3.更强大的方式：线程中断

• 线程中断是JDK中内置的类似于标记变量的终止线程的解决方案，但更强大更灵活。
• 线程中断并不会使线程立即退出，而是给线程发送一个 通知，告知目标线程，有人希望你退出了。至于目标线程接到通知后如何处理，则完全由目标线程 自行决定。
• 与线程中断有关的方法有三个：

1. // 中断线程
   public void Thread.interrupt()

2. // 判断是否被中断
   public boolean Thread.isInterrupted()
   具体实现：

   return isInterrupted(false); // false表示不清除中断状态
   

3. // 判断是否被中断，并清除当前中断状态
   public static boolean Thread.interrupted()
   具体实现：

   return currentThread().isInterrupted(true); // true表示清除
   

• 如果希望线程在收到中断通知后退出，就必须为它增加相应的 中断处理代码，否则中断通知不会产生任何作用。中断处理代码例如：

 while (true){
       if (Thread.currentThread().isInterrupted()){
           System.out.println("Interrupted!");
           break;
       }
       System.out.println("business code...");
 }

• 到目前为止介绍的线程中断功能，实际和设置标记变量没有任何区别。之所以说线程中断功能更加强大，是因为如果在循环体中出现了类似于 wait() 或者 sleep() 这样的操作，就只能通过中断来识别了。
• 看一下sleep方法的声明：

public static native void sleep(long millis) throws InterruptedException;

• 从声明中可以看出sleep方法抛出了一个 InterruptedException。这不是一个运行时异常，意味着程序必须捕获并处理它。当线程在sleep休眠时，如果被中断，这个异常就会产生。
• 如果不能在catch块中退出线程（例如必须进行后续的某些处理），那么必须调用interrupt()方法 再次中断自己，置上中断标记位。这是因为当由于中断而抛出异常时，会清除中断标记。run方法体内代码示例：

   while (true){
       if (Thread.currentThread().isInterrupted()){
           System.out.println("Interrupted!");
           break;
       }
       try {
           Thread.sleep(1000L);
       }catch (InterruptedException e){
           System.out.println("Interrupted When Sleep!");
           // break; //即时退出
           Thread.currentThread().interrupt(); //下次循环时退出
       }
   }

3.等待（wait）和通知（notify）

• 为了支持多线程之间的协作，JDK在 Object类 中提供了三个非常重要的接口：

public final void wait() throws InterruptedException
public final native void notify();
public final native void notifyAll();

• 如果一个线程调用了object.wait()，那么它就会进入object对象的 等待队列。当object.notify()被调用时，会从等待队列中 随机 选择一个线程并将其唤醒。object.notifyAll()方法和notify不同之处在于，会唤醒在等待队列中等待的 所有 线程。
• 需要注意的是，上述三个方法都必须包含在对应目标对象的 synchronized 语句中，以获得目标对象的 监视器。否则，会抛出 IllegalMonitorStateException
• 示例代码：

public class Test {
    private final static Object object = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (object) { // 获得监视器
                System.out.println(System.currentTimeMillis() + " -- wait1 thread start!");
                try {
                    object.wait(); // 释放监视器
                                   // 当被唤醒后，会在这里重新尝试获得监视器
                    System.out.println(System.currentTimeMillis() + " -- wait1 thread end!");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } // 释放监视器
        }).start();

        new Thread(() -> {
            synchronized (object) { // 获得监视器
                System.out.println(System.currentTimeMillis() + " -- wait2 thread start!");
                try {
                    object.wait(); // 释放监视器
                                   // 当被唤醒后，会在这里重新尝试获得监视器
                    System.out.println(System.currentTimeMillis() + " -- wait2 thread end!");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } // 释放监视器
        }).start();

        try {
            Thread.sleep(1000); //确保两个wait线程都start之后再让notifyAll线程start
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            synchronized (object) { // 获得监视器
                System.out.println(System.currentTimeMillis() + " -- notifyAll thread start!");
                object.notifyAll();
                System.out.println(System.currentTimeMillis() + " -- notifyAll thread end!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } // 释放监视器
        }).start();
    }
}
//输出：
//1531957572939 -- wait1 thread start!
//1531957572939 -- wait2 thread start!
//1531957573048 -- notifyAll thread start!
//1531957573048 -- notifyAll thread end!
//1531957575063 -- wait2 thread end!
//1531957577065 -- wait1 thread end!

• 注意，上述代码在线程中sleep了2秒，是为了能更明显地观察到wait线程在得到notify通知后，还是会先尝试重新获得object的对象锁（监视器）。
• Object.wait()和Thread.sleep()方法都可以让线程等待若干时间，除了Object.wait()可以被唤醒外，另一个主要区别就是Object.wait()会释放目标对象的 锁，而Thread.sleep()方法不会释放任何资源。

4.被废弃的：挂起（suspend）和继续执行（resume）

• 这两个操作是一对相反的操作，被挂起的线程，必须要等到resume()操作后，才能继续执行。
• 被 废弃 的原因：

1. suspend()在导致线程暂停的同时，并不会释放任何 锁资源 。因此任何想要访问被它暂用了的锁的线程，都会被牵连。
2. 如果resume()操作 意外 地在suspend()前就执行了，那么被挂起的线程可能很难有机会被继续执行。
3. 对与被suspend()函数挂起的线程，它的 线程状态 还是Runnable，这会严重影响对系统状态的判断。

• 一个反面示例：线程t2被永远挂起，且永远占用了对象u的锁，这对系统来说可能是致命的。

public class Test {
    public static final Object u = new Object();

    public static class MyThread extends Thread {
        public MyThread(String name) {
            super.setName(name);
        }
        @Override
        public void run() {
            synchronized (u) {
                System.out.println("in " + getName());
                Thread.currentThread().suspend();
                System.out.println("out " + getName());
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        t1.start();
        Thread.sleep(100); // 为了确保t1的resume()发生在suspend()之后
        t2.start();
        t1.resume();
        t2.resume();
        t1.join();
        t2.join();
    }
}
// 输出：
// in t1
// out t1
// in t2

• 可以用wait()和notify()在应用层面实现suspend()和resume()的功能。

5.等待线程结束（join）

• 很多情况下，一个线程的输入可能依赖于另一个或者多个线程的输出，这时，这个线程就需要等待依赖线程执行完毕，才能继续执行。JDK提供了join()操作来实现这个功能。
• 使用示例：（main线程等待precondition线程执行完毕后才会继续执行）

public class Test {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis() + "main start");

        Thread preconditionThread = new Thread(() -> {
            try {
                System.out.println(System.currentTimeMillis() + "precondition start");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new UnsupportedOperationException();
            }
            System.out.println(System.currentTimeMillis() + "precondition finish");
        });

        preconditionThread.start();
        try {
            preconditionThread.join();
        } catch (InterruptedException e) {
            throw new UnsupportedOperationException();
        }

        System.out.println(System.currentTimeMillis() + "main finish");
    }
}
// 输出：
// 1534130381159main start
// 1534130381288precondition start
// 1534130383288precondition finish
// 1534130383289main finish

• join()的本质是让调用线程wait()在当前线程对象示例上。因此需要注意的一点是：不要在Thread对象实例上使用类似wait()或者notify()等方法 ，因为这很有可能会影响系统API的工作，或这被系统API所影响。

6.谦让（yield）

• 方法声明：

public static native void yield();

• 这是一个静态方法，一旦执行，它会使当前线程让出CPU。在让出CPU后当前线程仍然会进行CPU资源的争夺，但是是否能够再次被分配到就不一定了。
• 如果觉得一个线程不那么重要，或者优先级非常低，而且害怕它会占用太多的CPU资源，那么可以在适当的时候调用Thread.yield()，给予其他重要线程更多的工作机会。

7.volatile关键字

• Java内存模型（JMM）都是围绕着原子性、可见性、有序性展开的。
• volatile对于保证操作的原子性有很大帮助（例如对32位系统中long类型变量的赋值），但是volatile并不能代替锁，它也无法保证一些复合操作的原子性（例如i++）。
• volatile也可以保证数据的可见性，对于多线程共享的变量，要用volatile修饰。
• volatile也可以保证有序性，可以阻止指令重排。

8.synchronized

• 一个volatile解决不了的问题（复合操作）：
  有一个计数器，两个线程同时对i进行累加（i++）操作，各执行1000000次，我们希望的执行结果是最终i的值可以达到2000000，但事实并非总是如此。如果将该代码执行多次，很多时候，i的最终值会小于2000000。这是因为两个线程同时对i进行写入时，其中一个线程的结果会覆盖另外一个（即使此时i被声明为volatile变量）。

  
  未命名文件(1).png-18.6kB

• 要从根本上解决这个问题，就必须保证多个线程在对i进行操作时完全同步。也就是说，当线程A在写入时，线程B不仅不能写，同时也不能读。因为在线程A写完之前，线程B读取的一定是一个过期数据。Java中通过synchronized关键字实现这个功能。

• synchronized的作用是实现线程间的同步。它的作用是对同步的代码加锁，使得每一次只能有一个线程进入同步块，从而保证线程间的安全性。

• synchronized的用法：

  1. 指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
  2. 直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
  3. 直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

• 需要避免的一个错误：一定要注意线程是否关注的是同一把锁，对于直接作用于实例方法的用法，以下两种使用方式是完全不同的：

Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
// 正确用法，使用的是一把锁

Thread tt1 = new Thread(new AccountingSyncBad());
Thread tt2 = new Thread(new AccountingSyncBad());
// 错误用法，使用的是两把锁

• 这种错误的另一种常见形式是：将声明为变量的不变对象作为锁。例如：String、Integer。如果在程序运行中，变量的值改变了，那么实际上这个变量指向的是另一个对象，即，又不是同一把锁了。

• 除了用于线程同步、确保线程安全外，synchronized还可以保证线程见的可见性和有序性。换言之，被synchronized限制的代码段，多个线程是以串行的方式执行的。

9.线程组

• 使用线程组可方便对大量的线程进行管理。
• 一个简单的使用实例：

public class Test {
    public static void main(String[] args) {
        ThreadGroup printGroup = new ThreadGroup("PrintGroup");
        Runnable print = () -> System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(printGroup, print, "T1");
        Thread t2 = new Thread(printGroup, print, "T2");
        t1.start();
        t2.start();
        System.out.println(printGroup.activeCount());
        printGroup.list();
    }
}
// activeCount()可以获得活动线程的总数，但由于线程是动态的，因此这个值只是一个估计值，无法准确确定。
// list()方法可以打印这个线程组中所有的线程信息，对调试有一定帮助。

• 线程组的stop()方法存在和Thread.stop()相同的问题，不建议使用。
• 对于线程和线程组，取一个好听的名字，对于排查问题，有很大帮助。

10.守护线程Deamon

• 守护线程是系统的守护者，在后台默默地完成一些系统性的服务，比如垃圾回收线程、JIT线程。
• 用户线程是系统的工作线程，它会完成这个程序应该要完成的业务操作。
• 如果用户线程全部结束，那么守护线程要守护的对象已经不存在了，整个应用程序就会自然结束，Java虚拟机会自然退出。
• 将一个程序设置为守护程序的方式：

thread.setDaemon(true);
thread.start();
// 注意调用的顺序

• 需要注意的是，设置守护线程必须在线程start()之前设置，否则会得到一个IllegalThreadStateException异常。但是程序和线程依然可以正常执行，只是被当做用户线程而已。

11.线程优先级

• 优先级高的线程在竞争资源时会更有优势，但无法预测且无法精准控制。因此在要求严格的场合，还是需要自己在应用层解决线程调度问题。
• 在Java中使用1到10表示线程优先级。一般可以用内置的三个静态常量表示：

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

---

END