Java并发编程的艺术读书笔记——Java并发编程基础

Posted 遇事不决问清风

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java并发编程的艺术读书笔记——Java并发编程基础相关的知识，希望对你有一定的参考价值。

学习参考资料：《Java并发编程的艺术》

文章目录

1、线程的几种状态

线程在运行的生命周期中可能处于六种状态其一：新建（初始）、就绪、运行、等待、阻塞、终止。

线程在自身的生命周期中，并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换；

Java 线程状态变迁如下图所示。

2、如何安全的终止线程

在了解如何安全终止线程前，先来看一个中断操作

  • 中断操作

    中断操作是一种简便的线程间交互方式，这种方式最适合用来取消或暂停任务。

    使用方法：其他线程通过调用该线程的interrupt()方法进行中断，使用isInterrupted()方法查看是否被中断。

  • 由变量控制是否终结

    除了中断以外，还可以利用一个boolean变量来控制是否需要暂停任务并终止该线程。

    如下例子，两个线程分别进行变量累加操作，过两秒后通过改变go变量来进行终止操作

    package com.thenie;

public class Shutdown 

    public static void main(String[] args) throws InterruptedException 
        Runner one = new Runner();
        Runner two= new Runner();
        Thread a1 = new Thread(one, "A1");
        Thread a2 = new Thread(two, "A2");
        //运行
        a1.start();
        a2.start();

        Thread.sleep(2000);
        //终止a2
        two.goShutDown();
    
    private static class Runner implements Runnable
        private volatile boolean go=true;//终止标识符

        @Override
        public void run() 
            int i=0;
            while(go && !Thread.currentThread().isInterrupted())
                System.out.println(Thread.currentThread().getName()+":"+ i++);
            
        

        public void goShutDown()
            go=false;

3、线程间通信（重要）

线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作，这将会带来巨大的价值。

线程间通信主要有两种类型共享内存和消息传递。

3.1共享内存

  1. volatile关键字

    volatile可以用来修饰字段（成员变量），每次修改过后会立刻写回主内存，并使缓存了这个变量的失效，保证了所有线程对变量访问的可见性。

  2. synchronized关键字

    synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

3.2消息传递

  1. 等待/通知机制

    等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

    • 等待/通知 的相关方法

    下面这个例子以父亲可以往篮子里放苹果和香蕉，儿子只可以拿苹果，女儿只能拿香蕉为例来模拟线程通信

    package com.thenie;


public class Eat 
    //flag 0：表示苹果和香蕉都没有  1：表示苹果  2：香蕉
    static volatile int flag=0;

    static Object lock =new Object();

    public static void main(String[] args) 
        Thread sonThread = new Thread(new Son(), "儿子");
        Thread daughterThread = new Thread(new Daughter(), "女儿");
        Thread fatherThread = new Thread(new Father(), "父亲");

        sonThread.start();
        daughterThread.start();
        fatherThread.start();

    
    static class Son implements Runnable

        @Override
        public void run() 
            while (true) 
                synchronized (lock) 
                    while (flag != 1) //条件不满足时
                        try 
                            lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    

                    flag = 0;
                    System.out.println(Thread.currentThread().getName() + ":" + "吃了[苹果]");
                    lock.notifyAll();
                
            
        
    
    static class Daughter implements Runnable

        @Override
        public void run() 
            while (true) 
                synchronized (lock) 
                    while (flag != 2) //条件不满足时
                        try 
                            lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    

                    flag = 0;
                    System.out.println(Thread.currentThread().getName() + ":" + "吃了[香蕉]");
                    lock.notifyAll();
                
            
        
    
    static class Father implements Runnable

        @Override
        public void run() 
            while (true) 
                synchronized (lock) 
                    while (flag != 0) //条件不满足时
                        try 
                            lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    

                    flag = (int) (Math.random() * 10) % 2 + 1;
                    System.out.println(Thread.currentThread().getName() + ":放了" + (flag == 1 ? "[苹果]" : "[香蕉]"));

                    lock.notifyAll();

    部分输出结果：

    父亲:放了[苹果]
儿子:吃了[苹果]
父亲:放了[香蕉]
女儿:吃了[香蕉]
父亲:放了[苹果]
儿子:吃了[苹果]
父亲:放了[香蕉]
女儿:吃了[香蕉]
父亲:放了[香蕉]
女儿:吃了[香蕉]
父亲:放了[苹果]
儿子:吃了[苹果]
父亲:放了[香蕉]
女儿:吃了[香蕉]

    • 等待/通知的经典范式

      从刚才的示例中可以提炼出等待/通知的经典范式，该范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。

      等待方遵循如下原则。

      1）获取对象的锁。
      2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
      3）条件满足则执行对应的逻辑。

      对应的伪代码如下：

      synchronized(对象) 
   while(条件不满足) 
      对象.wait();
    
   对应的处理逻辑

      通知方遵循如下原则。

      1）获得对象的锁。
      2）改变条件。
      3）通知所有等待在对象上的线程。
      对应的伪代码如下：

      synchronized(对象)
	改变条件
	对象.notifyAll();

  2. 管道输入/输出流

    管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
    管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。

    下面例子中，创建了 printThread，它用来接受 main 线程的输入，任何 main 线程的输入均通过 PipedWriter 写入，而 printThread 在另一端通过 PipedReader 将内容读出并打印。

    public class Piped 

    public static void main(String[] args) throws IOException 
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        // 将输出流和输入流进行连接，否则在使用时会抛出IOException
        out.connect(in);
        Thread printThread = new Thread(new Print(in), "PrintThread");
        printThread.start();
        int receive = 0;
        try 
            while ((receive = System.in.read()) != -1) 
                out.write(receive);
            
         finally 
            out.close();
        
    

    static class Print implements Runnable 

        private final PipedReader in;

        public Print(PipedReader in) 
            this.in = in;
        

        public void run() 
            int receive = 0;
            try 
                while ((receive = in.read()) != -1) 
                    System.out.print((char) receive);
                
             catch (IOException ignored)

    运行该示例，输入一组字符串，可以看到被printThread进行了原样输出：

    Repeat my words.
Repeat my words.

  3. Thread.join()的使用

    如果一个线程 A 执行了thread.join() 语句，其含义是：当前线程 A 等待 thread 线程终止之后才从 thread.join() 返回。

    线程 Thread 除了提供 join() 方法之外，还提供了join(long millis) 和 join(longmillis, int nanos) 两个具备超时特性的方法。这两个超时方法表示，如果线程 thread 在给定的超时时间里没有终止，那么将会从该超时方法中返回。

    在下面的例子中，创建了 10 个线程，编号 0~9，每个线程调用前一个线程的 join() 方法，也就是线程 0 结束了，线程 1 才能从 join() 方法中返回，而线程 0 需要等待 main 线程结束。

    public class Join 

    public static void main(String[] args) throws Exception 
        Thread previous = Thread.currentThread();
        for (int i = 0; i < 10; i++) 
            // 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
            Thread thread = new Thread(new Domino(previous), String.valueOf(i));
            thread.start();
            previous = thread;
        
        TimeUnit.SECONDS.sleep(5);
        System.out.println(Thread.currentThread().getName() + " terminate.");
    

    static class Domino implements Runnable 

        private final Thread thread;

        public Domino(Thread thread) 
            this.thread = thread;
        

        public void run() 
            try 
                thread.join();
             catch (InterruptedException ignored) 
            
            System.out.println(Thread.currentThread().getName() + " terminate.");

    输出如下。

    main terminate.
0 terminate.
1 terminate.
2 terminate.
3 terminate.
4 terminate.
5 terminate.
6 terminate.
7 terminate.
8 terminate.
9 terminate.

    从上述输出可以看到，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回

  4. ThreadLocal的使用

    • ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

    • 可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。

后面还会陆陆续续更新这系列的读书笔记，期待您的关注~~

以上是关于Java并发编程的艺术读书笔记——Java并发编程基础的主要内容，如果未能解决你的问题，请参考以下文章

java并发编程的艺术，读书笔记第六章 concurrentHashMap以及并发容器的介绍

java并发编程的艺术，读书笔记第三章

深入理解Java多线程 - Java并发编程的艺术

2017年读书笔记

《Java并发编程的艺术》读后笔记-part2

《Java并发编程的艺术》读后笔记-part1