doclist 阅读(128) 评论(0)

从我开始写博客到现在,已经写了不少关于并发编程的了,差不多还有一半内容整个并发编程系列就结束了,而今天这篇博客是比较简单的,只是介绍下并发编程的基础知识( = =!其实,对于大神来说,前面所有博客都是基础)。本来我不太想写这篇博客,因为这篇博客的很多内容都是以记忆为主,而且网上也有大把大把的博客,都写的相当不错,但是我最终决定还是要写一写,因为没有这篇博客,并发编程系列就不能算是一个完整的系列。

什么是线程

说到线程,不得不说到进程,因为线程是无法单独存在的,它只是进程中的一部分。
进程是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位。线程则是进程的一个执行路径,一个进程中至少有一个线程。操作系统在分配系统资源的时候,会把CPU资源分配给线程,因为真正执行工作,需要占用CPU运行的是线程,所以也可以说线程是CPU分配的基本单位。
在Java中,我们启动一个main函数,就启动了一个JVM的进程,而main函数所在的线程被称为“主线程”。
每个线程都有一个叫“程序计数器”的私有的内存区域,用来记录当前线程下一个要执行的指令地址,为什么要把程序计数器设计成私有的呢?因为线程是占用CPU的基本单位,而CPU一般是使用时间片轮转的方式来让线程占有的,所以当某个线程的时间片用完后,要让出CPU,等下一次获得时间片了,再继续执行。那么线程怎么知道之前的程序执行到哪里了呢?就是靠程序计数器。另外需要注意的是,如果执行的是native方法,那么程序计数器记录的是undefined地址。

线程的三种创建方式与区别

线程有三种创建方式,分别是

  1. 继承Thread类并重写run方法;
  2. 实现Runnable接口的run方法;
  3. 实现Callable泛型接口,并实现call方法。
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("run");
    }
}


public class MyTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}
class MyRannable implements Runnable {
    @Override
    public void run() {
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) {
        MyRannable myRannable = new MyRannable();
        new Thread(myRannable).start();
    }
}
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "MyCallable";
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String>futureTask=new FutureTask<>(new MyCallable());
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

相信前面两种方式不用多说,大家都懂。我们现在来看看第三种方式,首先定义了MyCallable类,并实现了Callable接口的call方法。在main方法中创建了FutureTask对象,传入了MyCallable对象,然后用Thread包装了FutureTask对象,随后启动,最后用futureTask提供的get方法获取结果,获取结果这一步是阻塞的。

在面试中,经常会问如下的问题:

  • 调用Thread的start方法会发生什么事情,线程会马上执行吗?
    不会,调用Thread的start方法,线程没有马上执行,它处于“就绪”的状态,需要获得CPU资源后才会执行。
  • 调用Thread的start和run方法,有什么区别?
    调用start方法,才会真正开启新的线程执行run中的方法,而调用run方法,只是和调用普通方法一样,不会开启线程。
  • 上面三种方式的区别是什么,优缺点?
    只有Thread才是真正的线程,其他两种方法都需要被Thread包装才可以成为线程,在run方法中,可以使用this来获得当前线程,不需要使用Thread.currentThread(),缺点在于Java是单继承的,如果继承了Thread类,就没有办法继承其他类了,这是比较致命的,还有一个致命的缺点:无法交给线程池管理。
    Runnable是接口,所以实现了Runnable接口,还可以继承其他的类,但是必须被Thread类包装才可以成为线程,可以被线程池管理。
    以上两种方法都是没有返回值的,所以第三种方式Callable出现了,也可以被线程池管理,同样的,也必须被Thread类包装才可以成为线程。

线程的状态

  • 新建:当创建Thread的实例后,此线程进行新建状态。如:Thread t1 = new Thread() 。(但是也有一些博客对这个提出了强烈的反对,认为new Thread()只是创建了一个普通的Java对象而已,和线程或者线程的状态八竿子打不着,不过认为创建Thread实例后,线程就处于新建状态的说法确实是主流)
  • 就绪:当调用了start方法后,线程不会马上执行,此时线程的状态是“就绪”,等待分配CPU资源。
  • 运行:线程获得CPU资源后,真正开始执行。
  • 死亡:当线程运行结束后,进入“死亡”状态,处于此状态的线程永远都不会再次进入“就绪”。
  • 阻塞:由于某种原因导致正在运行的线程让出CPU并暂停自己的执行,就进入了“阻塞”的状态,比如调用线程的sleep方法,对象的wait方法等。当满足条件被返回后,线程重新进入“就绪”的状态,再次等待分配CPU资源。

关于死亡和阻塞状态,其实说的不太完整,因为除了线程运行结束后这种“自然死亡”,还有一个情况,就是被stop了,但是Java已经不推荐使用stop等操作了,所以就忘记吧,阻塞也是同样的道理,也不推荐使用suspend方法了,也忘记它把。

线程通知与等待

在Java中,每个对象都继承了Object类,而在Object类中提供了通知和等待的操作,所以每个对象都有这样的操作,既然是线程的通知与等待,为什么要把它定义在Object类中?因为Java提供的锁,锁的是对象,而不是方法或是线程,所以自然要定义在Object类中。

wait

当一个线程调用共享变量的wait方法后,该线程会被阻塞挂起,直到发生以下的两个事情才返回:

  1. 其他线程调用了该对象的notify或者notifyAll方法;
  2. 其他线程调用了该线程的interrupt方法,该线程会被返回,并且抛出InterruptedException异常。
class MyRunnable implements Runnable {
    Object object=new Object();

    @Override
    public void run() {
        try {
           synchronized (object){
               object.wait();
               System.out.println("run");
           }
        } catch (InterruptedException e) {
            System.out.println("被中断了");
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
    }
}

运行结果:

被中断了
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.codebear.MyRunnable.run(MyTest.java:13)
    at java.lang.Thread.run(Thread.java:748)

首先新建了一个子线程,子线程内部获取了object的监视器锁,随后调用object的wait方法阻塞当前线程,主线程调用interrupt方法中断子线程,子线程被返回,并且产生了异常。

这也就是为什么我们在调用共享变量的wait方法的时候,Java“死皮赖脸”的要我们对异常进行处理的原因:
image.png

调用wait方法后,还会释放对共享变量的监视器锁,让其他线程可以进入临界区:

class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            synchronized (MyRunnable.class) {
                System.out.println("我是" + Thread.currentThread().getName() + ",我进入了临界区");
                MyRunnable.class.wait();
                Thread.sleep(Integer.MAX_VALUE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        thread1.start();
        Thread thread2 = new Thread(myRunnable);
        thread2.start();
    }
}

运行结果:

我是Thread-1,我进入了临界区
我是Thread-0,我进入了临界区

可以很清楚的看到,两个线程都进入了临界区。
线程A获取了共享对象的监视器锁后,进入了临界区,线程B只能等待,线程A调用了共享对象的wait方法后,释放了共享对象的监视器锁,让线程B也可以获得共享变量的监视器锁,并且进入临界区。

在调用共享变量的wait方法前,必须先对该共享变量进行synchronized操作,否则会抛出IllegalMonitorStateException异常:

class MyRunnable implements Runnable {
    Object object = new Object();

    @Override
    public void run() {
        try {
            object.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
    }
}

运行结果:

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.codebear.MyRunnable.run(MyTest.java:12)
    at java.lang.Thread.run(Thread.java:748)

另外需要注意的是,一个线程虽然从阻塞挂起的状态到就绪的状态,但是可能其他线程并没有唤醒它,这就是虚假唤醒,虽然虚假唤醒在实践中很少发生,但是防患于未然,比较严谨的做法就是在wait方法外面,包裹一个while循环,while循环的条件就是检测是否满足了被唤醒的条件,这样即使虚假唤醒发生了,该线程被返回了,由于被while包裹了,发现并没有满足被唤醒的条件,又会被再次wait。
如下所示:

  while(是否满足了被唤醒的条件) {
     object.wait();
  }

notify

wait方法是将当前线程阻塞挂起,那么必定有一个方法是唤醒此线程的,就像沉睡的白雪公主也在等待王子的到来,将她唤醒一样。
被唤醒的线程不能马上从wait方法处返回,并且继续执行,因为还需要再次获取共享变量的监视器锁(因为调用wait方法后,已经释放了监视器,所以这里需要再次获取)。
如果有多个线程都调用了共享变量的wait方法而被阻塞挂起,那么调用notify方法后,只会随机唤醒其中一个线程。
还有一点尤其需要注意:当调用共享变量的notify方法后,并没有释放共享变量的监视器锁,只有退出临界区或者调用wait方法后,才会释放共享变量的监视器锁,我们可以做一个实验:

class CodeBearRunnable implements Runnable {

    private Object object = new Object();

    @Override
    public void run() {
        synchronized (object) {
            object.notify();
            System.out.println("我是" + Thread.currentThread().getName() + LocalDateTime.now());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class NotifyTest {
    public static void main(String[] args) {
        CodeBearRunnable codeBearRunnable = new CodeBearRunnable();
        new Thread(codeBearRunnable).start();
        new Thread(codeBearRunnable).start();
    }
}

运行结果:

我是Thread-02019-04-28T18:12:19.195
我是Thread-12019-04-28T18:12:22.196

我们来分析下代码:当线程A获取了共享变量的监视器锁,进入了临界区,调用共享变量的notify方法,打印出当前的时间,随后sleep当前线程3秒。如果notify方法会释放锁,那么线程B打印出来时间和线程A打印出来的时间应该相差不大,但是可以很清楚的看到,打印出来的时间相差了3秒,说明了线程A调用共享变量的notify方法后,并没有释放共享变量的锁,只有退出了临界区,才释放了共享变量的锁。

notifyAll

如果有多个线程都调用了共享变量的wait方法而被阻塞挂起,那么调用notifyAll方法后,所有线程都会被唤醒。

最后,我们用一个常见的面试题来熟悉下wait/notify的应用:两个线程交替打印奇偶数:

class MyRunnable implements Runnable {
    static private int i = 0;

    @Override
    public void run() {
        try {
            while (i < 100) {
                synchronized (MyRunnable.class) {
                    MyRunnable.class.notify();
                    MyRunnable.class.wait();
                    System.out.println("我是" + Thread.currentThread() + ":" + i++);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();

        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

运行结果:
image.png

join

在开发中,我们经常会遇到这样的需求:等待某些事情都完成后,才可以继续执行。比如旅游网站查询某个产品的航班,航班可以分为去程和返程,我们可以开两个线程同时查询去程和返程的航班,等他们的结果都返回后,再执行其他操作。

class GoRunnable implements Runnable {
    @Override
    public void run() {
       System.out.println("查询去程航班");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ReturnRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("查询返程航班");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new GoRunnable());
        thread1.start();

        Thread thread2 = new Thread(new ReturnRunnable());
        thread2.start();
        System.out.println("开始查询航班,现在的时间是"+ LocalDateTime.now());
        thread1.join();
        thread2.join();
        System.out.println("航班查询完毕,现在的时间是"+ LocalDateTime.now());
    }
}

运行结果:

查询去程航班
查询返程航班
开始查询航班,现在的时间是2019-04-28T21:18:05.719
航班查询完毕,现在的时间是2019-04-28T21:18:10.654

如果是同步查询,那么查询航班的耗时应该在(5+3)秒左右,现在利用线程+join方法,两个线程同时执行,耗时5秒左右(取决于慢的那个),在实际项目中,可以提升用户的体验,大幅提高查询的效率。

这里仅仅是演示join的功能,如果在实际项目中遇到这样的场景应该不会用join这么“粗糙”的方法。

让我们再来看看当join遇到interrupt方法会擦出怎样的火花:

class GoRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("查询去程航班");
        for (; ; ) {
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new GoRunnable());
        thread1.start();
        Thread.currentThread().interrupt();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            System.out.println("主线程" + e.toString());
        }
    }
}

运行结果:

主线程java.lang.InterruptedException
查询去程航班

子线程内部是一个死循环,执行子线程后,中断主线程,在主线程中的thread1.join处抛出了异常。但是需要注意的是,因为中断的是主线程,所以是在主线程中抛出异常,这里我用try包住thread1.join()只是为了更好的展现错误,其实这里并不强制要求对异常进行捕获。

本来想用一篇博客就结束并发编程基础的,但是写起来才发现想多了,一是想把每个知识点都说的清楚一点,并给出各种例子来帮助大家更好的理解,二是并发编程基础的知识点确实挺多的,所以还是分两篇博客来吧。