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

时间:2024-07-09 16:35:20

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