参考资料：《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中内置的类似于标记变量的终止线程的解决方案，但更强大更灵活。
- 线程中断并不会使线程立即退出，而是给线程发送一个
通知，告知目标线程，有人希望你退出了。至于目标线程接到通知后如何处理，则完全由目标线程自行决定。 - 与线程中断有关的方法有三个：
// 中断线程
public void Thread.interrupt()-
// 判断是否被中断
public boolean Thread.isInterrupted()
具体实现：return isInterrupted(false); // false表示不清除中断状态 -
// 判断是否被中断，并清除当前中断状态
publicstaticboolean 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()操作后，才能继续执行。
- 被
废弃的原因：
- suspend()在导致线程暂停的同时，并不会释放任何
锁资源。因此任何想要访问被它暂用了的锁的线程，都会被牵连。 - 如果resume()操作
意外地在suspend()前就执行了，那么被挂起的线程可能很难有机会被继续执行。 - 对与被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变量）。
.png)
未命名文件(1).png-18.6kB 要从根本上解决这个问题，就必须保证多个线程在对i进行操作时完全同步。也就是说，当线程A在写入时，线程B不仅不能写，同时也不能读。因为在线程A写完之前，线程B读取的一定是一个过期数据。Java中通过synchronized关键字实现这个功能。
synchronized的作用是实现线程间的同步。它的作用是对同步的代码
加锁，使得每一次只能有一个线程进入同步块，从而保证线程间的安全性。-
synchronized的用法：
- 指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
- 直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
- 直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。
需要避免的一个错误：
一定要注意线程是否关注的是同一把锁，对于直接作用于实例方法的用法，以下两种使用方式是完全不同的：
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
