并发编程之美读书笔记 1

作者: 寻找傅里叶 | 来源:发表于2021-06-28 20:03 被阅读0次

并发编程之美-终章chat
并发编程之美读书笔记 1
并发编程之美-1
Java并发编程之美系列汇总
Java并发编程之美《1》
读 GitChat 线程三部曲笔记
Java内存模型精讲
并发编程之美系列
Java并发编程之美
JMM内存模型简介

线程的概念

线程不能独立存在,资源由操作系统分配给进程,但是CPU资源是分配给线程的.同一个进程内的线程:

共享: 堆(主要存放使用new操作创建的对象实例)和方法区(JVM加载的类,常量以及静态变量等)
独立: 程序计数器(获得CPU控制权后可以从计数器指定地址继续执行)和栈区域.

当启动main函数时,就相当于启动了一个JVM的进程,而main所在的线程就是该进程中的主线程.

如何创建线程

有三种方式:

继承Thread类,重写run方法:

// Thread1.java
public class Thread1 extends Thread{

    @Override
    public void run() {
        System.out.println("current-thread: "+this.getName());
        System.out.println("继承自Thread");
    }

    public static void main(String[] args) {
        Thread1 t = new Thread1();
        t.start();
    }
}

不需要使用currentThread就可以获取当前线程,但是不能再继承其他类

实现 Runnable方法,并重写run方法:

//Thread2.java
public class Thread2 implements Runnable{
    private String name;

    public Thread2(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("this is "+ name + " running");
        System.out.println("实现了Runnable接口");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Thread2("t1"));
        t1.start();
        Thread t2 = new Thread(new Thread2("t2"));
        t2.start();
    }
}

可以继承其他类,还可以添加参数区分

实现Callable接口的call方法:

//Thread3.java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Thread3 implements Callable<String> {
    @Override
    public String call(){
        System.out.println("使用FutureTask方式,可以有返回值");
        return "done";
    }

    public static void main(String[] args) throws InterruptedException {
        FutureTask<String> ft = new FutureTask<String>(new Thread3());
        Thread t = new Thread(ft);
        t.start();
        try {
            String result = ft.get();
            System.out.println(result);
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

具有返回值,可以使用get方法获得返回值.也可以继承其他类.

当调用Thread的start方法,线程只是进入了就绪状态,只有当cpu资源得到满足时,才会真正开始运行.run方法结束后,线程就处于终止状态.

wait与notify

wait与notify都是Object类中的方法.

wait

只有获得了变量的监视锁,才能调用该变量的wait方法,否则会抛出异常:

public class WaitExample {
    private int a;

    void incr() {
        a++;
    }

    int getA() {
        return a;
    }
    public static void main(String[] args) {
        WaitExample waitExample = new WaitExample();
        try {
            // wrong
            waitExample.wait();
            for (int i = 0; i < 20000; i++) {
                Thread t = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        waitExample.incr();
                    }
                });
                t.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println(waitExample.getA());

    }
}

运行结果:

java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.may.learning.WaitExample.main(WaitExample.java:17)
0

获得监视锁可以通过synchronized关键字:
比如在方法上加上关键字:

    synchronized void incr() {
        a++;
    }

或者,在调用时对该类加上关键字:

synchronized (waitExample) {
...
}

当调用wait时,只会释放当前变量的锁:

    public static void main(String[] args) throws InterruptedException{
        WaitExample waitExample = new WaitExample();
        WaitExample anotherWaitExample = new WaitExample();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (waitExample) {
                    System.out.println("t: get waitExample lock success!");
                    System.out.println("t: try get anotherWaitExample lock");
                    try {
                        synchronized (anotherWaitExample) {
                            System.out.println("t: get anotherWaitExample success!");
                            System.out.println("t: release waitExample lock");
                            // t只释放了waitExample的锁
                            waitExample.wait();

                        }
                    } catch (InterruptedException e) {
                        System.out.println("被中断");
                    }
                }

            }
        });
        t.start();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (waitExample) {
                    System.out.println("t1: get waitExample lock success!");
                    System.out.println("t1: try get anotherWaitExample lock");
                    try {
                        // 由于t未释放锁,因此t1获取不到anotherWaitExample的锁
                        synchronized (anotherWaitExample) {
                            System.out.println("t1: get anotherWaitExample success!");
                            System.out.println("t1: release waitExample lock");
                            waitExample.wait();

                        }
                    } catch (InterruptedException e) {
                        System.out.println("被中断");
                    }
                }

            }
        });
        t1.start();
        Thread.sleep(1000);
    }

运行结果:

t: get waitExample lock success!
t: try get anotherWaitExample lock
t: get anotherWaitExample success!
t: release waitExample lock
t1: get waitExample lock success!
t1: try get anotherWaitExample lock

如果需要指定时间,可以使用wait(long timeout)或者wait(long timeout, int nanos).
被wait挂起时,被中断时会抛出异常:

public class WaitExample {

    private int a;

    void incr() {
        a++;
    }

    int getA() {
        return a;
    }

    public static void main(String[] args) throws InterruptedException{
        WaitExample waitExample = new WaitExample();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (waitExample) {
                    waitExample.incr();
                    try {
                        waitExample.wait();
                    } catch (InterruptedException e) {
                        System.out.println("被中断");
                    }
                }

            }
        });
        t.start();
        Thread.sleep(1000);
        t.interrupt();
        System.out.println(waitExample.getA());
    }
}

运行结果:

1
被中断

notify

notify会唤醒被wait阻塞挂起的线程.与wait类似,需要获得了变量的监视锁后才能对其进行进行notify操作.如果有多个线程都在等待唤醒,那么会随机唤醒某一个线程.而notifyAll会唤醒所有阻塞等待的线程.
类似wait方法，notify也需要先获得对象的监视锁（但是notify不会释放锁）。

    public static void main(String[] args) throws InterruptedException {
        NotifyExample notifyExample = new NotifyExample();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (notifyExample) {
                        System.out.println("t1 挂起");
                        notifyExample.wait();
                        System.out.println("t1 被唤醒了");
                    }
                } catch (InterruptedException e) {
                    System.out.println("被中断了");
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (notifyExample) {
                        System.out.println("t2 挂起");
                        notifyExample.wait();
                        System.out.println("t2 被唤醒了");
                    }
                } catch (InterruptedException e) {
                    System.out.println("被中断了");
                }
            }
        });
        t2.start();
        Thread.sleep(1000);
        synchronized (notifyExample) {
            notifyExample.notify();
        }
    }

运行结果:

t1 挂起
t2 挂起
t1 被唤醒了

如果将notifyExample.notify()换成notifyExample.notifyAll(),那么t1和t2都能被唤醒:

t1 挂起
t2 挂起
t2 被唤醒了
t1 被唤醒了

生产者消费者

利用wait和notify写一个简单的生产者消费者:

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumer {

    public static void main(String[] args) throws InterruptedException {
        Queue<Integer> queue = new LinkedList<>();
        Thread producer = new Thread(new Runnable() {
            @Override
            public void run() {
                int i=0;
                synchronized (queue) {
                    while (true){
                        try {
                            if (!queue.isEmpty()) {
                                queue.wait();
                            }else{
                                queue.add(++i);
                                System.out.println("生产了"+i);
                                queue.notify();
                            }
                        } catch (InterruptedException e) {
                            System.out.println("被中断了");
                            return;
                        }
                    }
                }
            }
        });
        Thread consumer = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (queue) {
                    while (true){
                        try{
                            if (queue.isEmpty()) {
                                queue.wait();
                            }else{
                                int i = queue.poll();
                                System.out.println("消费了"+i);
                                queue.notify();
                            }
                        }catch (InterruptedException e){
                            System.out.println("被中断了");
                            return;
                        }
                    }
                }
            }
        });
        producer.start();
        consumer.start();
        Thread.sleep(10000);
        producer.interrupt();
        consumer.interrupt();
    }
}

运行结果:

...
生产了782421
消费了782421
生产了782422
消费了782422
生产了782423
消费了782423
生产了782424
被中断了
被中断了

join

wait与notify属于Ojbect的方法,而join是Thread的方法.
调用某一线程的join方法,可以使当前线程（下例中的main线程）阻塞等待该线程完成:

public class JoinTest {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("t 结束了!");
                } catch (InterruptedException e) {
                    System.out.println("被中断了");
                }
            }
        });
        t.start();
        t.join();
        System.out.println("main 结束了!");
    }
}

运行结果:

t 结束了!
main 结束了!

sleep

sleep和wait 一样可以挂起当前线程,被中断时也会抛出异常.但不同的是它是属于Thread的方法,并且它不会释放对象的监视锁.指定睡眠时间到达后,会进入就绪状态,等待cpu的调度.

public class SleepTest {
    public static void main(String[] args) throws InterruptedException {
        SleepTest sleepTest = new SleepTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (sleepTest){
                    try {
                        System.out.println("t1 获取到锁");
                        Thread.sleep(60000);
                    } catch (InterruptedException e) {
                        System.out.println("被中断了!");
                    }
                }
            }
        });
        t1.start();
        Thread.sleep(1000);
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t2 等待锁");
                synchronized (sleepTest) {
                    System.out.println("t2 获取到锁了");
                }
            }
        });
        t2.start();
        Thread.sleep(2000);
        t1.interrupt();
    }
}

运行结果:

t1 获取到锁
t2 等待锁
被中断了!
t2 获取到锁了

yield

线程会主动让出自己的cpu时间,并不会被挂起,只是进入了就绪状态.但是下一次仍然可能被调度到.

中断

前面已经使用了interrupt很多次,需要注意与isInterrupted以及interrupted进行区分.
isInterrupted: 判断当前线程是否被中断;
interrupted: 判断当前线程是否被中断,并且复位(清除中断标志);

使用interrupted判断中断并且复位:

public class InterruptTest {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.interrupted()) {

                }
                System.out.println("t1 is Interrupted: "+Thread.currentThread().isInterrupted());
            }
        });
        t1.start();
        t1.interrupt();
        t1.join();
        System.out.println("done");
    }
}

运行结果:

t1 is Interrupted: false
done

需要注意的是调用线程的interrupt方法,只是为该线程设置中断位.当线程在运行时,会立即往下执行.而当被wait,join或者sleep方法阻塞挂起时,才会抛出InterruptedException异常,此时中断位会被恢复,如下面这个例子:

public class InterruptTest throws InterruptedException{

    public static void main(String[] args){
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t1 running");
                while (true) {
                }
            }
        });
        t1.start();
        t1.interrupt();
        System.out.println("main thread isInterrupted: " + Thread.interrupted());
        System.out.println("t1 isInterrupted: " + t1.isInterrupted());
        boolean isInterrupted = Thread.interrupted();
        System.out.println("isInterrupted: " + isInterrupted);
        System.out.println("main thread isInterrupted: " + Thread.interrupted());
        System.out.println("t1 isInterrupted: " + t1.isInterrupted());
        t1.join();
        System.out.println("done");
    }
}

输出结果:

main thread isInterrupted: false
t1 isInterrupted: true
isInterrupted: false
main thread isInterrupted: false
t1 running
t1 isInterrupted: true

因为t1并没有被挂起,所以即使中断位为true,也仍然在继续运行,不会输出"done".而interrupted针对是当前线程,也就是主线程,所以中断标志位一直是false.
如果在阻塞情况下,中断位会被马上复位,对上面的例子稍加修改:

public class InterruptTest {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    while (!Thread.currentThread().isInterrupted()) {
                        System.out.println("t1: running");
                        Thread.sleep(1000);
                    }
                }catch (Exception e){
                    System.out.println("t1 被中断");
                    System.out.println("thread t1 isInterrupted : "+Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
        System.out.println("main thread isInterrupted: " + Thread.interrupted());
        System.out.println("t1 isInterrupted: " + t1.isInterrupted());
        t1.join();
        System.out.println("done");
    }
}

运行结果:

t1: running
t1 被中断
thread t1 isInterrupted : false
main thread isInterrupted: false
t1 isInterrupted: false
done

主线程中的isInterrupted仍然是false,但是打印出的t1的isInterrupted由于处在阻塞状态被中断,中断位又被复位成了false.

上下文切换与死锁

当出现:

CPU时间用尽,线程进入就绪状态时
被其他线程中断时

会出现上下文的切换.

避免死锁的出现,可以采用不同线程都按照相同的顺序去请求资源,保证资源获取的有序一致性.

守护线程与用户线程

守护线程的存在不影响JVM的退出,只要最后一个用户线程没有退出,正常情况下JVM也不会退出.
JVM没有退出:

public class DaemonTest {

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {

                }
            }
        });
//        t.setDaemon(true);
        t.start();
        System.out.println("main exit");
    }
}

运行结果:

main exit

将t利用setDeamon设置为守护线程的注释打开,运行结果:

main exit

Process finished with exit code 0

原理是,main运行后,JVM会自动启动一个叫做DestoryJavaVM的线程,它会等待所有用户线程结束后终止JVM进程.

ThreadLocal

如果创建了一个ThreadLocal变量,每个访问这个变量的线程都会获得一个副本.

public class ThreadLocalTest {
    static ThreadLocal<Integer> val = new ThreadLocal<>();

    static void print(String string) {
        System.out.println(string + ":" + val.get());
    }
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                val.set(1);
                for (int i = 0; i < 50; i++) {
                    int v = val.get();
                    v++;
                    val.set(v);
                }
                print("thread1");
                val.remove();
                print("after remove thread1");
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                val.set(1);
                for (int i = 0; i < 50; i++) {
                    int v = val.get();
                    v += 2;
                    val.set(v);
                }
                print("thread2");
                val.remove();
                print("after remove thread2");
            }
        });
        t1.start();
        t2.start();
        System.out.println("done");
    }
}

运行结果:

thread1:51
after remove thread1:null
done
thread2:101
after remove thread2:null

ThreadLocal的原理:

Thread中有一个threadLocals变量,它的类型是ThreadLocal.ThreadLocalMap,实际上是一个hashMap.
当使用set方法赋值时:

// ThreadLocal.java
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

getMap方法获得的是threadLocals,如果不为空,将当前threadLocal变量作为key,设置的值作为value放入进行存储,而如果为空,则利用createMap进行初始化.

// ThreadLocal.java
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

需要注意的是createMap中传入的是当前线程,因为需要为其设置threadLocals变量的值.而threadLocals中的key实际上是ThreadLocal变量,也就是可以理解为:thread1.threadLocals -> {ThreadLocal@xxx:1, ThreadLocal@yyy:"hello"}

但是ThreadLocal不支持继承,如果需要继承父线程的值,需要使用InheritableThreadLocal:

public class InheritThreadLocalTest {
    static InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();

    static void print(String str) {
        System.out.println(str + ":" + inheritableThreadLocal.get());
    }

    public static void main(String[] args) {
        inheritableThreadLocal.set("hello");
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                String initVal = inheritableThreadLocal.get();
                if (initVal != null) {
                    inheritableThreadLocal.set(initVal+" world");
                }
                print("thread 1");
            }
        });
        t.start();
        print("main");
        System.out.println("done");
    }
}

运行结果:

main:hello
done
thread 1:hello world

InheritableThreadLocal和ThreadLocal的set方法是一样的,区别在于createMap,它将变量写入了inheritableThreadLocals里:

    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }

在初始化线程的时候,init方法会设置inheritableThreadLocals:

    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals){
...
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
...
}

它会将父线程的inheritableThreadLocals都复制到自己的inheritableThreadLocals中.

并发编程之美-终章chat
一、Java 并发编程之美：并发编程高级篇之五微信扫码二维码加入本 Chat 作为 Java 并发编程之美系列的...
并发编程之美读书笔记 1
线程的概念线程不能独立存在,资源由操作系统分配给进程,但是CPU资源是分配给线程的.同一个进程内的线程: 共享:...
并发编程之美-1
主要用来记录一些自己觉得重点的知识不定期更新读书笔记欢迎关注、点赞 ? [TOC] 马桶?Java 上厕所就...
Java并发编程之美系列汇总
Java并发编程之美系列汇总，大家可以挑选自己感兴趣的的进行订阅。 Java 并发编程之美：线程相关的基础知识ht...
Java并发编程之美《1》
前提：不知道你是否和小编一样的困惑？由于小编感觉自己每次学习都不够深入，都只是停留在用的阶段，也会刷视频，但是视频...
读 GitChat 线程三部曲笔记
GitChat线程三部曲 Java 编程之美 - 线程相关的基础知识 Java 编程之美：并发编程高级篇之一 Ja...
Java内存模型精讲
1.JAVA 的并发模型共享内存模型在共享内存的并发模型里面,线程之间共享程序的公共状态,线程之间通过读写内存...
并发编程之美系列
一、前言借用 Java 并发编程实践中的话：编写正确的程序并不容易，而编写正常的并发程序就更难了。相比于顺序执行...
Java并发编程之美
一、前言并发编程相比 Java 中其他知识点学习门槛较高，从而导致很多人望而却步。但无论是职场面试，还是高并发/...
JMM内存模型简介
1.并发编程模型的两个关键问题并发编程中需要处理两个关键问题：线程之间如何通信和线程之间如何同步。通信是指线程之...

并发编程之美读书笔记 1

线程的概念

如何创建线程

wait与notify

wait

notify

生产者消费者

join

sleep

yield

中断

上下文切换与死锁

守护线程与用户线程

ThreadLocal

相关文章

并发编程之美-终章chat

并发编程之美读书笔记 1

并发编程之美-1

Java并发编程之美系列汇总

Java并发编程之美《1》

读 GitChat 线程三部曲笔记

Java内存模型精讲

并发编程之美系列

Java并发编程之美

JMM内存模型简介

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读