Java多线程--线程及相关的Java API

Java多线程--线程及相关的Java API

线程与进程

进程是线程的容器，程序是指令、数据的组织形式，进程是程序的实体。

一个进程中可以容纳若干个线程，线程是轻量级的进程，是程序执行的最小单位。我们研究多线程而不是多进程，因为线程之间的切换与调度的成本远小于进程。

线程的生命周期

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WATING,
    TERMINATED;
}

线程的所有状态都在枚举类State中定义了，其中：

NEW表示刚刚创建的线程，此时线程还没有开始执行。调用start()后线程进入RUNNABLE状态，线程在执行过程中遇到synchronized同步块，就进入BLOCKED阻塞状态，此时线程暂停执行，直到获得请求的锁。WAITING和TIMED_WAITING都表示等待，区别是前者是无时间限制的等待，后者是有时限的等待。等待可以是执行wait()方法后等待notify()方法将其唤醒，也可以是通过join()方法等待的线程等待目标线程的执行结束。一旦等待了期望事件，线程再次执行，从等待状态变成RUNNABLE状态。线程执行结束后，进入TERMINATED状态。

Java中的线程API

线程的新建

Thread t = new Thread();
t.start();

如上就创建了一个线程，要想这个线程创建后做点什么，需要覆写Thread类中的run()方法。

Thread t = new Thread();
t.run();

不能使用上面的方式启动线程，这样调用不会产生任何新的线程，只是一个单纯的方法调用。要想开启线程，不能使用run()，而应该用start()。

还可以通过实现Runnable接口，覆写接口中的run()方法，然后在Thread的构造函数中传入Runnale，此方法更为常用。

new Thread(new Runnale() {
    @Override
    public void run() {}
}).start();

由于run()是Runnable接口中的唯一方法，在Java8种可以简单写成：

new Thread(() -> {}).start();

线程的终止

Thread类中有个stop()方法，但是已经被废弃。该方法太过暴力，强行把执行到一半的线程终止掉，可能会引起数据不一致的问题。stop()方法会直接终止线程，并立即释放这个线程持有的锁，而锁恰好是用来维持对象的一致性的。

举个例子User类中有id和name两个字段，一开始id = 1, name = "ming", 我们要set数据id = 2, name = "jun"更新user，若刚写入了id = 2，name还没来得及写入就stop()的话，立即释放锁，因此其他线程得到锁读取这个对象的话，就会得到id = 2, name = "ming"，这不是我们想要的结果，数据已经被写坏了！

那么要如何终止线程呢？可以自定义退出线程的方法，比如设置标志位

volatile boolean stoped;
public void myStop() {
    stoped = true;
}

在线程合适的地方, 通过判断stoped变量来手动退出线程。

@Override
public void run() {
    while (true) {
        if (stoped) {
            break;
        }
    }
    // synchronized (object) {do sth.}
}

线程的中断

线程中断不会使线程立即退出，而是通知目标线程“你应该退出了”，退不退出是由目标线程来决定的。

Thread类有个实例interrupt()方法，它通知目标线程中断，也就是设置中断标志位。

另一个实例方法isInterrupt()用于判断当前线程是否被中断(通过检查中断标志位)；

静态方法Thread.interrupted()也可以判断当前线程的中断状态，但同时会清除当前线程的中断标志位。

wait()和notify()

wait()是Object的方法，也就是说每个对象都能调用。在当前线程中某个对象调用了wait()方法则该线程就停止执行，转为等待状态。举个例子，在线程T中，调用了obj.wait()，线程T就进入了对象obj的等待队列，则线程T就在对象obj上等待，一直等到其他线程调用了obj.notify()，这时obj从它的等待队列中随机唤醒一个线程（不一定是刚才的线程T）。所以notify()方法唤醒的选择不是公平的，不是说先等待的线程就一定会先被唤醒。

Object类还有一个notifyAll()方法，会唤醒某对象等待队列中的所有线程。

notify()和wait()方法在执行前必须获得对象的锁。为此在synchronized (obj)中先获得了锁，才能调用wait()或者notify()方法，wait()会立刻释放锁，而notify()不会立刻释放锁，wait()状态的线程也不能立刻获得锁；等到执行notify()的线程退出同步块后，才释放锁，此时其他处于wait()状态的线程才能获得该锁。

线程的挂起和继续执行

Thread类中还有两个已经被废弃的方法，分别是suspend()和resume()。

suspend()在导致线程暂停的同时，不会释放任何锁，而且线程状态还是Runnable，其他任何线程都得不到被该线程占用的锁，直到在线程上执行了resume()，被挂起的线程才能继续，其他阻塞在相关锁上的线程也才可以继续执行。但是如如resume()不小心在suspend()之前调用了，可能造成线程被永久挂起，从而永久占用锁。

注意和notify()、wait()方法的区别。由于方法已被废弃，不再讨论更多。

join()和yield()

join()表示将线程“加入”到当前线程中，会一直阻塞当前线程，直到该线程执行完毕，或者说：当前线程一直等待join入的线程执行完毕后，才能继续执行。

public class Abc {
    public static volatile int i;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {for (i = 0; i < 100; i++);});
        t.start();
        t.join();
        System.out.println(i);
    }
}

举个例子，上面的代码中有main线程和t线程，由于线程t的join，使得main线程中System.out.println(i)的一定是等待t线程执行完毕后才能执行，因此打印值一定是100.

join()的实现依赖于wait()。A线程中调用了B线程的join方法，则相当于A线程调用了B线程的wait方法，在调用了B线程的wait方法后，A线程就会进入阻塞状态。所以A线程会等待B执行完毕后才能继续执行。

yield()表示主动礼让当前线程的CPU使用权，让出不是会不会回来参与CPU资源的争夺，下次还能被分配到。调用该方法，好比是当前线程说：我的工作暂时做完，给其他线程一些工作机会。

volatile关键字

volatile可以确保变量的可见性、有序性，不保证复杂操作的原子性。所以volatite对于原子性操作只能说有一定的帮助，但不能取代锁。

当用volatile修饰一个变量时，相当于告诉虚拟机，这个变成极有可能被某些线程修改，确保该变量在被修改后，其他线程能“看到”该变量已经被改变。

synchronized

上面说了volatile不能真正保证线程安全，只能保证一个线程修改了数据后，其他线程能看到这个改变。两个线程同时修改同一个共享变量时，仍然会产生冲突。

为了保证操作的原子性，可以使用同步块，synchronized

被synchronized修饰的方法，或被其包起来的代码段，任何时候只有一个线程可以执行。这就避免了多个线程修改同一个数据的危险。synchronized可以实现线程间的同步，主要是对被同步的代码加锁。

Dog dog = new Dog();

• 指定的加锁对象，如synchronized (dog) {}或者synchronized (Dog.class) {}
• 作用于实例方法上，如public synchronized void fun() {}，此时使用的锁是当前实例。
• 作用于静态方法，如public static synchronized void fun() {}，此时使用的锁是当前类。

注意：为了保证线程间同步，使得在多个线程间修改同一个数据时，保证任何时候只有一个线程能修改。多个线程需要使用同一把锁。

因为synchronized中的代码任何时候只能有一个线程在执行它，所以可以说被synchronized限制的多个线程是串行执行的。

线程的其他概念

线程组

ThreadGroup类可以容纳多个线程，可以将多个功能相同的线程放入线程组中，便于管理。

守护线程（Daemon）

守护线程用于守护用户进程。守护进程在后台默默完成一些系统性的服务，比如垃圾回收线程、JIT线程就可理解成守护线程。而用户线程是用于完成程序的业务操作的，当程序中的所有用户线程执行完毕，守护线程没有了可守护的对象，程序自然就退出。即：在一个Java程序中只有守护线程时，虚拟机就自然退出。

public static void main(String[] args) {
    Thread t = new Thread(() -> {
        while (true) {
        }
    });
    t.setDaemon(true);
    t.start();
    System.out.println("over");
}

在上面的代码中，线程t被设置成守护线程（必须在start()之前调用），用户线程main在打印"over"后执行完毕，t没有要守护的线程了，所以程序会出，如果不设置t为守护线程，我们知道由于while (true)程序永远不会退出。

线程的优先级

Java的线程有优先级，高优先级线程在竞争资源时更有优势，但这也是个概率问题，高优先级也可能抢占失败，低优先级线程也不是说一定会饥饿。

Java中的线程有1~10的优先级，数字越大，优先级越高。Thread类中内置了三个默认的优先级，如下。

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

---

by @sunhaiyu

2018.4.13