乐趣区

关于java:Java并发多线程基础总结

jiezi

线程外围一：实现多线程的正确姿态

实现多线程到底有几种

网上有说 2 种，3 种，4 种，6 种等等 ????‍♂️

咱们看 Oracle 官网 API 是怎么形容的。

官网形容为 两种：

  • 继承 Thread 类
  • 实现 Runnable 接口

有两种办法能够创立新的执行线程。一种是将一个类申明为 Thread 的子类。该子类应重写 Thread 类的 run 办法。而后能够调配并启动子类的实例。

public class ThreadTest extends Thread {

    @Override
    public void run() {System.out.println("线程执行....");
    }

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

创立线程的另一种办法是申明一个实现 Runnable 接口的类。而后，该类实现 run 办法。而后能够调配该类的实例，在创立 Thread 时将其作为参数传递并启动。

public class RunnableTest implements Runnable{

    @Override
    public void run() {System.out.println("线程执行....");
    }

    public static void main(String[] args) {new Thread(new RunnableTest()).start();}
}

两种形式的比照

实现 Runnable 接口绝对于继承 Thread 类来说，有如下显著的益处：

  • 1、适宜多个雷同程序代码的线程去解决同一资源的状况，把虚构 CPU（线程）同程序的代码，数据无效的拆散，较好地体现了面向对象的设计思维。
  • 2、能够防止因为 Java 的单继承个性带来的局限。咱们常常碰到这样一种状况，即当咱们要将曾经继承了某一个类的子类放入多线程中，因为一个类不能同时有两个父类，所以不能用继承 Thread 类的形式，那么，这个类就只能采纳实现 Runnable 接口的形式了。
  • 3、有利于程序的健壮性，代码可能被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享雷同的代码。多个线程操作雷同的数据，与它们的代码无关。当线程被结构时，须要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了 Runnable 接口的类的实例。

两种办法的 实质 区别：

通过 Thread 的 run()办法源码咱们能够看到如下代码：

@Override
public void run() {if (target != null) {target.run();
    }
}

如果 target 不等于 null 则，调用 target 的 run 办法，因而咱们能够猜到 target 就是 Runnable 对象。

/* What will be run. */
private Runnable target;

因为咱们通过继承 Thread 类的时候曾经重写了 run()办法，所以并不会执行这段代码。

如果咱们是通过实现 Runnable 接口的话，在创立 Thread 对象的时候就通过结构器传入了以后实现 Runnable 接口的对象，所以 target 不等于 null。

由此咱们能够晓得：

  • 继承 Thread 类：run()办法整个被重写
  • 实现 Runnable 接口：最终调用 target.run()

思考：如果同时继承了 Thread 类又实现了 Runnable 会呈现什么状况？

  public static void main(String[] args) {new Thread(() -> {System.out.println("我来自 Runnable");
        }) {
            @Override
            public void run() {System.out.println("我来自 Thread");
            }
        }.start();}
我来自 Thread

简略点一句话来说，就是咱们笼罩了 Thread 类的 run()，外面的 target 那几行代码都被咱们笼罩了。所以必定不会执行 Runnable 的 run()办法了。

总结

精确的讲，创立线程只有一种形式那就是结构 Thread 类，而实现线程的执行单元有两种形式。

  1. 实现 Runnable 接口的 run()办法，并把 Runnable 实例传给 Thread 类。
  2. 继承 Thread 类，重写 Thread 的 run()办法。

典型错误观点剖析

线程池 创立线程也算是一种新建线程的形式

咱们通过线程池源码，能够看到底层还是通过 Thread 类来新建一个线程传入了咱们的 Runnable。

通过 Callable 和 FutureTask 创立线程，也算是一种新建线程的形式

就不过过多赘述了，很分明的能够看到，还是应用到了 Thread 类，和实现 Runnable 接口。

无返回值是实现 Runnable 接口，有返回值是实现 callable 接口，所以 callable 是新的实现线程的形式

还是通过 Runnable 接口来实现的。

典型错误观点总结

多线程的实现形式，在代码中写法变幻无穷，但其本质万变不离其宗。

线程外围二：多线程启动的正确姿态

start()办法和 run()办法区别是什么？

代码演示：

public static void main(String[] args) {Runnable runnable = () -> {System.out.println(Thread.currentThread().getName());
      };
      runnable.run();
      new Thread(runnable).start();}
main
Thread-0

咱们能够发现执行了 run()办法是有主线程来执行的，并不是新建了一个线程。

run()和 start()的区别能够用一句话概括：独自调用 run()办法，是同步执行；通过 start()调用 run()，是异步执行。

start()办法原理解读

  • start()办法含意：

启动新线程

  1. start()办法调用后，并不意味着该线程立马运行，只是告诉 JVM 在一个适合的工夫运行该线程。有可能很长时间都不会运行，比方遇到饥饿的状况。
  2. 调用 start()的先后顺序并不能决定线程执行的程序。

筹备工作

首先会让本人处于就绪状态。就绪状态指的是，我曾经获取到除了 CPU 以外的其余资源。比方该线程曾经设置了上下文，栈，线程状态，以及 PC，做完筹备工作后，线程才能够被 JVM 或者操作系统进一步调度到执行状态。调度到执行状态后，期待获取 CPU 资源，而后才会进入到运行状态，执行 run()办法外面的代码。

不能反复调用 start()办法

不然会出现异常：java.lang.IllegalThreadStateException

start()办法源码解析

  • 启动新线程查看线程状态
public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {start0();
            started = true;
        } finally {
            try {if (!started) {group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
}

咱们看到第一行语句就是：

if (threadStatus != 0)
throw new IllegalThreadStateException();

而 threadStatus 初始化就是 0。

/* Java thread status for tools,
* initialized to indicate thread 'not yet started'
*/
private volatile int threadStatus = 0;
  • 退出线程组
  • 调用本地办法 start0()

run()办法原理解读

在 Thread 类源码中咱们之前曾经看过了只有三行代码，其实只是一个普普通通的办法。

@Override
public void run() {if (target != null) {target.run();
    }
}

线程外围三：线程进行、中断的正确姿态

如何正确进行线程？

应用 interrupt()办法 来 告诉 ，而不是 强制。

interrupt() 字面上是中断的意思，但在 Java 里 Thread.interrupt()办法实际上通过某种形式告诉线程，并不会间接停止该线程。

因为绝对于开发人员，被进行线程的自身更分明什么时候进行。

与其说如何正确进行线程，不如说是如何正确告诉线程。

代码示例：

public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new ThreadTest());
        thread.start();
        Thread.sleep(500);
        thread.interrupt();}

    @Override
    public void run() {
        int i = 0;
        while (i <= Integer.MAX_VALUE / 2) {if (i % 20000 == 0) {System.out.println(i);
            }
            i++;
        }
        System.out.println("工作执行实现");
    }
}

因为打印进去数据特地的多，我就只展现最初一部分输入后果：

1073680000
1073700000
1073720000
1073740000
工作执行实现

感兴趣的话，能够试一下该段代码，能够发现在 0.5 秒后发动的告诉线程中断并没有反馈，咱们的 run() 办法还是执行到了最初。（执行工夫超过 0.5 秒）

这样咱们也证实了 interrupt () 办法确实是没有立刻暂停线程。

咱们须要在 while 条件里减少一个判断，在每一次循环时候判断是否曾经发动告诉中断请求。

public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new ThreadTest());
        thread.start();
        Thread.sleep(500);
        thread.interrupt();}

    @Override
    public void run() {
        int i = 0;
        while (!Thread.currentThread().isInterrupted() && i <= Integer.MAX_VALUE / 2) {if (i % 20000 == 0) {System.out.println(i);
            }
            i++;
        }
        System.out.println("工作执行实现");
    }
}

运行后果：

70900000
70920000
70940000
70960000
工作执行实现

咱们能够很分明的看到，1073740000 70960000 两个数值差距十分大，证实确实是在 0.5 秒后就中断了线程。

另外一种状况就是在线程睡眠的时候咱们告诉中断会怎么？

上代码：

public class ThreadTest {public static void main(String[] args) {Runnable runnable = () -> {
            try {
                int i = 0;
                while (!Thread.currentThread().isInterrupted() && i <= 300) {if (i % 100 == 0) {System.out.println(i);
                    }
                    i++;
                }
                Thread.sleep(5000);
            } catch (InterruptedException e) {System.out.println("线程在睡眠中被吵醒了！");
                e.printStackTrace();}
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        thread.interrupt();}
}

运行后果：

0
100
200
300
线程在睡眠中被吵醒了！java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.suanfa.thread.ThreadTest.lambda$main$0(ThreadTest.java:16)
    at java.lang.Thread.run(Thread.java:748)

通过代码咱们能够看到在睡眠中咱们进行告诉中断的话会报出 InterruptedException 异样，所以在写代码的过程中要及时处理 InterruptedException 能力正确进行线程。

另还有一种状况就是在循环中每次线程都会睡眠的时候咱们告诉中断会怎么？

上代码：

public class ThreadTest {public static void main(String[] args) {Runnable runnable = () -> {
            try {
                int i = 0;
                while (!Thread.currentThread().isInterrupted() && i <= 30000) {if (i % 100 == 0) {System.out.println(i);
                    }
                    i++;
                    Thread.sleep(10);
                }
            } catch (InterruptedException e) {System.out.println("线程在睡眠中被吵醒了！");
                e.printStackTrace();}
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {Thread.sleep(5000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        thread.interrupt();}
}

运行后果：

0
100
200
300
400
线程在睡眠中被吵醒了！java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.suanfa.thread.ThreadTest.lambda$main$0(ThreadTest.java:14)
    at java.lang.Thread.run(Thread.java:748)

后果还是会在 5 秒后抛出了 InterruptedException 异样。

然而咱们其实不必在 while 条件中退出 !Thread.currentThread().isInterrupted() 的判断，因为在告诉中断时候，发现线程在 sleep 中的话，也会进行中断。

如果循环中蕴含 sleep 或者 wait 等办法则不须要在每次循环中查看是否曾经收到中断请求。

理论开发中的两种最佳实际

  • 第一种：优先选择：传递 中断

咱们先看一段代码：

public class ThreadTest {public static void main(String[] args) {Runnable runnable = () -> {while(!Thread.currentThread().isInterrupted()){System.out.println("执行了 while 里的代码");
                throwInMethod();}
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        thread.interrupt();}

    private static void throwInMethod() {
        try {Thread.sleep(2000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}

这段代码看起来貌似没什么问题。然而请留神 肯定肯定不要在最内层来进行 try/catch。否则就会如下后果所示：

执行了 while 里的代码
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.suanfa.thread.ThreadTest.throwInMethod(ThreadTest.java:24)
    at com.suanfa.thread.ThreadTest.lambda$main$0(ThreadTest.java:9)
    at java.lang.Thread.run(Thread.java:748)
执行了 while 里的代码
执行了 while 里的代码
执行了 while 里的代码
执行了 while 里的代码
执行了 while 里的代码

咱们发现异常是抛出来了，然而里面的 run()办法仍旧在进行 while 循环。并且因为曾经抛出了 InterruptedException 异样，咱们的 while 条件中的 !Thread.currentThread().isInterrupted() 曾经被重置了。所以会始终循环上来，稍不留神线程就无奈被回收。

解决办法：将异样抛给 run() 办法来解决。

public class ThreadTest {public static void main(String[] args) {Runnable runnable = () -> {
            try {while (!Thread.currentThread().isInterrupted()) {System.out.println("执行了 while 里的代码");
                    throwInMethod();}
            } catch (InterruptedException e) {e.printStackTrace();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        thread.interrupt();}

    private static void throwInMethod() throws InterruptedException {Thread.sleep(2000);
    }
}

运行后果：

执行了 while 里的代码
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.suanfa.thread.ThreadTest.throwInMethod(ThreadTest.java:27)
    at com.suanfa.thread.ThreadTest.lambda$main$0(ThreadTest.java:10)
    at java.lang.Thread.run(Thread.java:748)

肯定要留神，不要将 try/cath 写在 while 外面！否则还是会有限循环

  • 第二种：不想或无奈传递：复原 中断

这种状况下咱们在最内层的办法中 try/catch 了当前肯定要在 catch 或者 finally 中从新设置中断即可。

public class ThreadTest {public static void main(String[] args) {Runnable runnable = () -> {while (!Thread.currentThread().isInterrupted()) {System.out.println("执行了 while 里的代码");
                throwInMethod();}
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        thread.interrupt();}

    private static void throwInMethod() {
        try {Thread.sleep(2000);
        } catch (InterruptedException e) {e.printStackTrace();
        } finally {Thread.currentThread().interrupt();}
    }
}

运行后果：

执行了 while 里的代码
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.suanfa.thread.ThreadTest.throwInMethod(ThreadTest.java:24)
    at com.suanfa.thread.ThreadTest.lambda$main$0(ThreadTest.java:9)
    at java.lang.Thread.run(Thread.java:748)

响应中断的办法总结列表

  • Object.wait()
  • Thread.sleep()
  • Thread.join()
  • BlockingQueue.take() / put()
  • Lock.lockInterruptibly()
  • CountDownLatch.await()
  • CyclicBarrier.await()
  • Exchanger.exchange()
  • java.nio.channels.InterruptibleChannel 的相干办法
  • java.nio.channels.Selector 的相干办法

谬误的进行办法

  • 被弃用的 stop()、suspend()、resume() 办法
  • 用 volatile 设置 boolean 标记位

volatile 能够应用然而要分场景：

  • 在没有阻塞的时候，能够应用 volatile
  • 在有阻塞的状况下，volatile 不再实用

进行线程相干重要函数解析

判断 是否 已被中断相干办法

  • static boolean interrupted()：返回以后线程是否曾经被中断

在 Thread 里中源码咱们能够看到他传入了一个 true，这个参数的意思是是否革除中断状态。

  public static boolean interrupted() {return currentThread().isInterrupted(true);
    }
  • boolean isInterrupted()：返回以后线程是否曾经被中断

在 Thread 里中源码咱们能够看到他传入了一个 false，也就是不革除标记位状态。

    public boolean isInterrupted() {return isInterrupted(false);
    }
  • Thread.interrupted()的目标对象

咱们上面代码：

public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {Thread thread01 = new Thread(new ThreadTest());
        thread01.start();
        Thread.sleep(500);
        thread01.interrupt();
        System.out.println(thread01.isInterrupted()); //true
        System.out.println(Thread.interrupted());  //false
        System.out.println(thread01.isInterrupted()); //true
    }

    @Override
    public void run() {while (true){}}
}

可能有些人会感觉答案不应该是 true true false 吗？

重点就是在这句 Thread.interrupted()， 执行这句话的是 main 线程，所以判断的就是 main 线程的状态，后果为 false，因为并没有革除掉 Thread-0 线程的标记位状态，所以他还是 true。

上面例子能够表白的很明确：

public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {Thread thread01 = new Thread(new ThreadTest());
        thread01.start();
        Thread.sleep(500);
        System.out.println("在 main 办法里判断："+thread01.isInterrupted());
    }

    @Override
    public void run() {Thread.currentThread().interrupt();
        System.out.println("在 run 办法里判断："+Thread.currentThread().isInterrupted());
        System.out.println("调用革除标记位的判断办法:" + Thread.interrupted());
        System.out.println("在 run 办法里判断："+Thread.currentThread().isInterrupted());
    }
}

运行后果：

在 run 办法里判断：true
调用革除标记位的判断办法:true
在 run 办法里判断：false
在 main 办法里判断：false

线程外围四：解释线程申明周期的正确姿态

线程一共有 六种 状态

  • 新建状态（New）

新创建了一个线程对象，但还没有调用 start()办法。

  • 可运行状态（Runnable）

在 Java 虚拟机中执行的线程处于此状态。此状态阐明了线程曾经取得 cpu 的执行势力，但蕴含两种执行状态：
1、Ready：线程可执行，但以后 cpu 被其余正在执行的线程占用，而处于期待中。
2、Running：线程可执行，且正在 cpu 中处于执行状态。

  • 阻塞状态（Blocked）

线程阻塞于锁。

  • 有限期待状态（Waiting）

进入该状态的线程须要期待其余线程做出一些特定动作（告诉或中断）。

  • 限时期待状态（Timed Waiting）

线程因调用 sleep 办法处于休眠状态中，规定工夫后可醒来，回到可运行状态（Runnable）。

  • 终止状态（Terminated）

示意该线程曾经执行结束。

上面代码先展现一下新建状态、可运行状态、终止状态

public class ThreadTest implements Runnable {public static void main(String[] args) {Thread thread = new Thread(new ThreadTest());
        System.out.println(thread.getState());
        thread.start();
        System.out.println(thread.getState());
        try {Thread.sleep(2000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(thread.getState());
    }

    @Override
    public void run() {for (int i = 0; i < 10; i++) {
            try {Thread.sleep(10);
                System.out.print(i);
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getState());
    }
}

运行后果：

NEW
RUNNABLE
0123456789RUNNABLE
TERMINATED

能够看到即便在运行中，状态也是 Runnable 而不是 Running。

接下来咱们看一下限时期待状态、有限期待状态、阻塞状态

public class ThreadTest implements Runnable {public static void main(String[] args) {ThreadTest threadTest = new ThreadTest();
        Thread thread1 = new Thread(threadTest);
        Thread thread2 = new Thread(threadTest);
        thread1.start();
        thread2.start();
        System.out.println(thread1.getState());
        System.out.println(thread2.getState());
        try {Thread.sleep(1300);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(thread1.getState());
    }

    @Override
    public void run() {sync();
    }

    private synchronized void sync()  {
        try {Thread.sleep(1000);
            wait();} catch (InterruptedException e) {e.printStackTrace();
        }

    }
}

运行后果：

TIMED_WAITING
BLOCKED
WAITING

个别习惯而言，把 Blocked、Waiting、Timed_waiting 都成为阻塞状态

线程外围五：解释 Thread 和 Object 类中线程办法的正确姿态

办法概览

类 办法 简介
Thread sleep 在指定的毫秒数内让以后“正在执行的线程”休眠（暂停执行）
Thread join 期待其它线程执行结束
Thread yield 放弃曾经取得到的 cpu 资源
Thread currentThread 获取以后执行线程的援用
Thread start、run 启动线程相干
Thread interrtupt 中断线程
Thread stop、suspend 已废除
Object wait、notify、notifyAll 让线程暂停劳动和唤醒

wait、notify、notifyAll 办法详解

wait

当调用了 wait()办法后，以后线程进入 阻塞 阶段，同时会开释锁，直到以下四种状况之一产生时，才会被唤醒。

  • 另一个线程调用这个对象的 notify()办法，随机唤醒的正好是以后线程。
  • 另一个线程调用这个对象的 notifyAll()。
  • 设置了 wait(long timeout)的超时工夫，如果传入 0 就是永恒期待。
  • 线程本身调用了 interrupt()办法。

notify、notifyAll

notify 的作用就是唤醒某一个线程（随机唤醒）。

notifyAll 的作用就是唤醒所有期待的线程。

代码演示 wait 和 notify 的根本用法：

/**
 * 演示 wait 和 notify 的根本用法
 * 1. 钻研代码执行程序
 * 2. 证实 wait 开释锁
 */
public class ThreadTest {public static Object object = new Object();

    public static void main(String[] args) {Thread01 thread01 = new Thread01();
        thread01.start();
        try {Thread.sleep(200);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        Thread02 thread02 = new Thread02();
        thread02.start();}

    static class Thread01 extends Thread {

        @Override
        public void run() {synchronized (object) {System.out.println(Thread.currentThread().getName() + "开始执行！");
                try {object.wait();
                } catch (InterruptedException e) {e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "又取得到锁！");
            }
        }
    }

    static class Thread02 extends Thread {

        @Override
        public void run() {synchronized (object) {System.out.println(Thread.currentThread().getName() + "执行 notify()办法！");
                object.notify();}
        }
    }

}

运行后果：

Thread- 0 开始执行！Thread- 1 执行 notify()办法！Thread- 0 又取得到锁！

代码演示 notifyAll：

public class ThreadTest implements Runnable {public static final Object object = new Object();

    public static void main(String[] args) {Runnable r = new ThreadTest();
        Thread threadA = new Thread(r, "thread01");
        Thread threadB = new Thread(r, "thread02");
        threadA.start();
        threadB.start();
        try {Thread.sleep(500);
        } catch (InterruptedException e) {e.printStackTrace();
        }

        Thread thread03 = new Thread(() -> {synchronized (object) {System.out.println(Thread.currentThread().getName() + "开始 notifyAll!");
                object.notifyAll();}
        }, "thread03 线程");
        thread03.start();}

    @Override
    public void run() {synchronized (object) {System.out.println(Thread.currentThread().getName() + "开始执行！");
            try {object.wait();
            } catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "又取得到锁！");
        }
    }
}

运行后果：

thread01 开始执行！thread02 开始执行！thread03 线程开始 notifyAll!
thread02 又取得到锁！thread01 又取得到锁！

由此后果能够晓得，先 start 的在 notifyAll 后不肯定先取得到锁。

须要留神的是，wait 只是开释以后锁

wait、notify、notifyAll 特点、性质

  • 应用之前必须 先获取到monitor，也就是取得到锁，不然会抛出IllegalMonitorStateException
  • 只能唤醒其中 一个
  • 属于 Object 类
  • wait 只是开释以后锁
  • 相似性能的Condition

实现生产者消费者设计模式

public class ProducerConsumer {public static void main(String[] args) {EventStorage eventStorage = new EventStorage();
        Producer producer = new Producer(eventStorage);
        Consumer consumer = new Consumer(eventStorage);
        new Thread(producer).start();
        new Thread(consumer).start();}

}

class Producer implements Runnable {

    private EventStorage storage;

    public Producer(EventStorage storage) {this.storage = storage;}

    @Override
    public void run() {for (int i = 0; i < 20; i++) {storage.put();
        }
    }
}

class EventStorage {
    private int maxSize;
    private LinkedList<Date> storage;

    public EventStorage() {
        maxSize = 10;
        storage = new LinkedList<>();}

    public synchronized void take() {while (storage.size() == 0) {
            try {wait();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
        System.out.println("拿到了" + storage.poll() + ", 当初仓库还剩下" + storage.size());
        notify();}

    public synchronized void put() {while (storage.size() == maxSize) {
            try {wait();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
        storage.add(new Date());
        System.out.println("仓库目前有" + storage.size() + "个产品了");
        notify();}
}

class Consumer implements Runnable {

    private EventStorage storage;

    public Consumer(EventStorage storage) {this.storage = storage;}

    @Override
    public void run() {for (int i = 0; i < 20; i++) {storage.take();
        }
    }
}

运行后果：

仓库目前有 1 个产品了
仓库目前有 2 个产品了
仓库目前有 3 个产品了
仓库目前有 4 个产品了
仓库目前有 5 个产品了
仓库目前有 6 个产品了
仓库目前有 7 个产品了
仓库目前有 8 个产品了
仓库目前有 9 个产品了
仓库目前有 10 个产品了
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 9
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 8
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 7
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 6
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 5
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 4
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 3
仓库目前有 4 个产品了
仓库目前有 5 个产品了
仓库目前有 6 个产品了
仓库目前有 7 个产品了
仓库目前有 8 个产品了
仓库目前有 9 个产品了
仓库目前有 10 个产品了
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 9
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 8
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 7
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 6
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 5
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 4
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 3
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 2
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 1
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 0
仓库目前有 1 个产品了
仓库目前有 2 个产品了
仓库目前有 3 个产品了
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 2
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 1
拿到了 Mon Sep 14 16:27:28 CST 2020, 当初仓库还剩下 0

wait、notify、notifyAll 常见面试题

  • 手写生产着消费者设计模式
  • 为什么 wait()须要在 同步代码块 中应用？

如果咱们不从同步上下文中调用 wait() 或 notify() 办法，咱们将在 Java 中收到 IllegalMonitorStateException。

然而为什么呢？

比方生产者是两个步骤：

count+1;

notify();

消费者也是两个步骤：

查看 count 值；

睡眠或者减一；

万一这些步骤混淆在一起呢？比如说，初始的时候 count 等于 0，这个时候消费者查看 count 的值，发现 count 小于等于 0 的条件成立；就在这个时候，产生了上下文切换，生产者进来了，噼噼啪啪一顿操作，把两个步骤都执行完了，也就是收回了告诉，筹备唤醒一个线程。这个时候消费者刚决定睡觉，还没睡呢，所以这个告诉就会被丢掉。紧接着，消费者就睡过去了……

  • 为什么线程通信办法 wait()，notify()和 notifyAll()被定义在 Object 类中？

Wait-notify 机制是在获取对象锁的前提下不同线程间的通信机制。在 Java 中，任意对象都能够当作锁来应用，因为锁对象的任意性，所以这些通信办法须要被定义在 Object 类里。

  1. 在 java 的内置锁机制中，每个对象都能够成为锁，也就是说每个对象都能够去调用 wait，notify 办法，而 Object 类是所有类的一个父类，把这些办法放在 Object 中，则 java 中的所有对象都能够去调用这些办法了。
  2. 一个线程能够领有多个对象锁，wait，notify，notifyAll 跟对象锁之间是有一个绑定关系的，比方你用对象锁 Object 调用的 wait()办法，那么你只能通过 Object.notify()或者 Object.notifyAll()来唤醒这个线程，这样 jvm 很容易就晓得应该从哪个对象锁的期待池中去唤醒线程，如果用 Thread.wait()，Thread.notify()，Thread.notifyAll()来调用，虚拟机基本就不晓得须要操作的对象锁是哪一个。
  • wait 办法属于 Object 对象，那调用 Thread.wait 会怎么？

首先，Thread 是一个一般的对象，然而 Thread 类有点非凡。

在线程完结的时候，JVM 会主动调用线程对象的 notifyAll 办法(为了配合 join 办法)。

防止在 Thread 对象上应用 wait 办法。

sleep 办法详解

作用：只想让线程在预期的工夫执行，其它工夫不要占用 cpu 资源。

特点：不开释锁，包含 synchronized，Lock。

演示 sleep 不开释锁代码：

public class ThreadTest implements Runnable {public static void main(String[] args) {ThreadTest threadTest = new ThreadTest();
        new Thread(threadTest).start();
        new Thread(threadTest).start();}

    @Override
    public void run() {synchronized (this) {System.out.println(Thread.currentThread().getName() + "开始执行！");
            try {TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "退出同步代码块！");
        }
    }
}

运行后果：

Thread- 0 开始执行！Thread- 0 退出同步代码块！Thread- 1 开始执行！Thread- 1 退出同步代码块！

总结

sleep 办法能够让线程进入 Waiting 状态，并且不占用 CPU 资源，然而不开释锁，直到规定工夫后再执行，休眠期间如果被中断，会抛出异样并革除中断状态。

join 办法详解

作用：是期待这个线程完结。

用法 ：t.join() 办法阻塞调用此办法的线程进入 TIMED_WAITING 状态，直到线程 t 实现，此线程再持续；

代码演示：

public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        Thread thread1 = new Thread(threadTest);
        thread1.start();
        Thread thread2 = new Thread(threadTest);
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("主线程执行结束！");
    }

    @Override
    public void run() {
        try {TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束！");
    }
}

运行后果：

Thread- 0 执行结束！Thread- 1 执行结束！主线程执行结束！

然而如果咱们正文掉两行 join()会怎么呢？

运行如下：

主线程执行结束！Thread- 0 执行结束！Thread- 1 执行结束！

这就是 join()的根本用法。

在 join 期间 mian 线程状态为 WAITING.

剖析 join 源码

public final void join() throws InterruptedException {join(0);
}
public final synchronized void join(long millis) throws InterruptedException {long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {while (isAlive()) {wait(0);
            }
        } else {while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {break;}
                wait(delay);
                now = System.currentTimeMillis() - base;}
        }
    }

参数 millis 传递为 0 的意思是有限睡眠工夫。

第一个 if 就是如果参数小于 0 就抛出异样。

如果等于 0 或者不等 0 最终都会进行 wait，而如果 == 0 咱们 wait(0)的话，咱们晓得这样就会有限睡眠。

可是咱们的代码并没有进行 notify，他是如何醒的呢？

其实后面咱们曾经讲过一次了。在线程完结的时候，JVM 会主动调用线程对象的 notifyAll 办法(为了配合 join 办法)。

join 办法 常见面试题

  • join 期间，线程处于哪有线程状态？

在 join 期间线程处于 WAITING 状态。

yield 办法详解

作用：开释我的 CPU 工夫片。须要留神的是，执行 yield()后，线程状态仍然是 RUNNABLE 状态，并不会开释锁，也不会阻塞。可能会在下一秒 CPU 调度又会调度以后线程。

定位：JVM 不保障遵循

总结：举个例子：一帮人在排队上公交车，轮到 Yield 的时候，他忽然说：我不想先上去了，咱们大家来比赛上公交车。而后所有人就一块冲向公交车。有可能是其他人先上车了，也有可能是 Yield 先上车了。

然而线程是有优先级的，优先级越高的人，就肯定能第一个上车吗？这是不肯定的，优先级高的人仅仅只是第一个上车的概率大了一点而已，最终第一个上车的，也有可能是优先级最低的人。并且所谓的优先级执行，是在大量执行次数中能力体现进去的。

线程外围六：理解线程各属性的正确姿态

概览

属性 用处
编号（ID） 每个线程都有本人的 ID，用于标识不同的线程
名称（Name） 让用户或者程序员在开发、调试中更容易辨别和定位问题
是否是守护线程（isDaemon） true 代表【守护线程】，false 代表【用户线程】
优先级（Priority） 这个属性目标是通知线程调度器，咱们心愿那些线程多运行，哪些少运行

线程 ID

id 是自增有小到大，从 0 开始。然而在一开始就进行了自增操作所以是 从 1 开始。

private static synchronized long nextThreadID() {return ++threadSeqNumber;}

代码演示：

public class ThreadTest {public static void main(String[] args) {System.out.println("主线程 id 为："+Thread.currentThread().getId());
        Thread thread = new Thread();
        System.out.println("子线程 id 为："+thread.getId());
    }
}

运行后果：

主线程 id 为：1
子线程 id 为：10

为什么是 10 呢？其实不难理解，因为在随同着 JVM 启动的时候也会有一些线程跟着启动，比方：Finalizer、Reference Handler、Signal Dispatcher 等。

线程名称

其实就是在一开始的时候线程初始化调配的默认名称，同时调用的 nextThreadNum()办法是被 synchronized 润饰的，并且从 0 开始，不会呈现反复的名称。

public Thread() {init(null, null, "Thread-" + nextThreadNum(), 0);
}
private static int threadInitNumber;
private static synchronized int nextThreadNum() {return threadInitNumber++;}

咱们接下来看一下批改名字的源码

public final synchronized void setName(String name) {checkAccess();
    if (name == null) {throw new NullPointerException("name cannot be null");
    }

    this.name = name;
    if (threadStatus != 0) {setNativeName(name);
    }
}

后面做了查看之后，咱们进行 name 赋值，然而线程状态如果是未启动状态下，咱们能够批改本地 native 办法去批改线程名称。如果在曾经启动阶段，咱们只能批改 Java 中的线程名称。

守护线程

作用：给用户线程提供服务。比方：垃圾收集线程

守护线程的三个个性：

  1. 线程类型默认 继承 自父线程
  2. 被谁 启动
  3. 不影响JVM 退出

守护线程和一般线程的区别

  • 整体无区别
  • 惟一区别在于是否能影响 JVM 的退出。只有用户线程执行结束 JVM 就会敞开退出。

线程优先级

线程蕴含 10 个级别，最小为 1，最大为 10，默认为 5。

   /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

但咱们程序设计 不应该依赖优先级。

因为不同操作系统不一样。在 win 中只有 7 个级别，而 linux 中没有优先级别。

并且优先级会被操作系统扭转。

总结

属性名称 用处 注意事项
编号（ID） 标识不同的线程 唯一性，不容许被批改
名称（Name） 定位问题 清晰有意义的名字；默认的名称
是否是守护线程（isDaemon） 守护线程、用户线程 二选一；继承父线程；setDaemon()
优先级（Priority） 绝对多运行 默认和父线程优先级相等，共有 10 个等级，不应该依赖

线程外围七：解决线程异样的正确姿态

为什么须要 UncaughtExceptionHandler？

  1. 因为在子线程中产生的异样并不会影响主线程的运行。
public class ThreadTest implements Runnable {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new ThreadTest());
        thread.start();
        int num = 0;
        TimeUnit.SECONDS.sleep(3);
        for (int i = 0; i < 1000; i++) {num ++;}
        System.out.println(num);
    }

    @Override
    public void run() {throw new RuntimeException();
    }
}

运行后果：

Exception in thread "Thread-0" java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:25)
    at java.lang.Thread.run(Thread.java:748)
1000
  1. 子线程异样无奈用传统办法捕捉。
public class ThreadTest implements Runnable {public static void main(String[] args) {
        try {new Thread(new ThreadTest()).start();
            new Thread(new ThreadTest()).start();
            new Thread(new ThreadTest()).start();} catch (RuntimeException e) {System.out.println("捕捉到了异样");
        }
    }

    @Override
    public void run() {throw new RuntimeException();
    }
}

运行后果：

Exception in thread "Thread-0" Exception in thread "Thread-1" Exception in thread "Thread-2" java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:24)
    at java.lang.Thread.run(Thread.java:748)
java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:24)
    at java.lang.Thread.run(Thread.java:748)
java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:24)
    at java.lang.Thread.run(Thread.java:748)

咱们发现还是会抛出三个异样，因为 try/catch 只解决以后线程也就是主线程的异样，所以会生效。

两种解决方案

  • 计划一，在每个 run 办法里进行 try/catch（不举荐）
  • 计划二，利用 UncaughtExceptionHandler（举荐）

UncaughtExceptionHandler 接口

在这个接口中只蕴含一个办法

@FunctionalInterface
public interface UncaughtExceptionHandler {
    /**
        * Method invoked when the given thread terminates due to the
        * given uncaught exception.
        * <p>Any exception thrown by this method will be ignored by the
        * Java Virtual Machine.
        * @param t the thread
        * @param e the exception
        */
    void uncaughtException(Thread t, Throwable e);
}

实现一个简略的异样处理器：

public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {

    @Override
    public void uncaughtException(Thread t, Throwable e) {Logger logger = Logger.getAnonymousLogger();
       logger.log(Level.WARNING,"线程异样，已终止"+t.getName(),e);
    }
}
public class ThreadTest extends MyUncaughtExceptionHandler implements Runnable {public static void main(String[] args) {Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        new Thread(new ThreadTest()).start();
        new Thread(new ThreadTest()).start();}

    @Override
    public void run() {throw new RuntimeException();
    }
}

运行后果：

九月 14, 2020 8:33:23 下午 com.suanfa.thread.MyUncaughtExceptionHandler uncaughtException
正告: 线程异样，已终止 Thread-0
java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:20)
    at java.lang.Thread.run(Thread.java:748)

九月 14, 2020 8:33:23 下午 com.suanfa.thread.MyUncaughtExceptionHandler uncaughtException
正告: 线程异样，已终止 Thread-1
java.lang.RuntimeException
    at com.suanfa.thread.ThreadTest.run(ThreadTest.java:20)
    at java.lang.Thread.run(Thread.java:748)

线程外围八：了解线程平安的正确姿态

什么是线程平安

《Java Concurrency In Practice》的作者 Brian Goetz 对“线程平安”有一个比拟失当的定义：“当多个线程拜访一个对象时，如果 不必思考 这些线程在运行时环境下的调度和交替执行，也不须要进行额定的同步 ，或者在调用方进行其它的协调操作，调用这个对象的行为都能够取得 正确的后果，那这个对象就是线程平安的。”

什么状况下会呈现线程平安问题，怎么防止？

  • 第一种：运行后果出错

a++ 多线程下呈现后果谬误问题

代码演示：

public class ThreadTest implements Runnable {
    static int num = 0;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        Thread thread = new Thread(threadTest);
        thread.start();
        Thread thread1 = new Thread(threadTest);
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(num);
    }

    @Override
    public void run() {for (int i = 0; i < 10000; i++) {num++;}
    }
}

运行后果：

14876

后果能够看到没有达到 20000，随机性十足。

简略了解就是咱们线程 1 进行加 1 后，然而并没有赋值给 i，这个时候 cpu 调度切换到了线程 2，线程 2 这个时候拿到的 i 还是 1，也进行了加 1，最初进行赋值为 2，而线程 1 也赋值 2。后果就会导致不满 20000 的问题。

  • 第二种：死锁

死锁是指两个或两个以上的过程在执行过程中，因为竞争资源或者因为彼此通信而造成的一种阻塞的景象。

代码演示死锁：

public class ThreadTest implements Runnable {static Object o1 = new Object();
    static Object o2 = new Object();
    int flag = 1;

    public static void main(String[] args) {ThreadTest threadTest01 = new ThreadTest();
        ThreadTest threadTest02 = new ThreadTest();
        threadTest02.flag = 2;
        new Thread(threadTest01).start();
        new Thread(threadTest02).start();}

    @Override
    public void run() {if (flag == 1) {synchronized (o1) {System.out.println("我拿到 flag =" + flag + "拿到第一把锁！");
                try {TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {e.printStackTrace();
                }
                synchronized (o2) {System.out.println("我拿到 flag =" + flag + "拿到第二把锁！");
                }
            }
        } else {synchronized (o2) {System.out.println("我拿到 flag =" + flag + "拿到第二把锁！");
                try {TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {e.printStackTrace();
                }
                synchronized (o1) {System.out.println("我拿到 flag =" + flag + "拿到第一把锁！");
                }
            }
        }
    }
}

运行后果：

咱们能够发现 flag = 1 的迟迟取得不到第二把锁，flag = 2 的也迟迟取得不到第一把锁。就造成了死锁，互相期待的场面。

  • 对象 公布 和初始化 时候的平安问题

什么是公布？

公布 (publish) 对象意味着其作用域之外的代码能够拜访操作此对象。例如将对象的援用保留到其余代码能够拜访的中央，或者在非公有的办法中返回对象的援用，或者将对象的援用传递给其余类的办法。

什么是逸出？

  • 1. 办法返回一个 private 对象
public class ThreadTest {private List<Integer> list = new ArrayList<>();

    public List<Integer> getList() {return list;}

}

  • 2. 还未实现初始化 (构造函数未齐全执行结束) 就把对象提供给外界

    • 在构造函数中未初始化结束就 this 赋值
    • 隐式逸出 – 注册监听事件
    • 构造函数中运行线程
public class ThreadTest {

    static Test test;

    public static void main(String[] args) throws InterruptedException {new Thread(() ->{new Test();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println(test);
    }

}

class Test {
    private int i;
    private int j;

    public Test() {
        this.i = 1;
        ThreadTest.test = this;
        try {TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        this.j = 2;
    }

    @Override
    public String toString() {return "Test{" + "i=" + i + ", j=" + j + '}';
    }
}

运行后果：

Test{i=1, j=0}

能够发现并没有初始化完 j。

如何防止逸出

  • 办法返回一个 private 对象

咱们返回一个 ” 正本 ”

private List<Integer> list = new ArrayList<>();

public List<Integer> getList() {return new ArrayList<>(list);
}
  • 还未实现初始化 (构造函数未齐全执行结束) 就把对象提供给外界

导致 this 援用逸出须要满足两个条件：

一个是在构造函数中创立外部类(EventListener)，另一个是在构造函数中就把这个外部类给公布了进来(source.registerListener)。

因而，咱们要避免这一类 this 援用逸出的办法就是防止让这两个条件同时呈现。

也就是说，如果要在构造函数中创立外部类，那么就不能在构造函数中把他公布了，应该在构造函数外公布，即等构造函数执行完初始化工作，再公布外部类。

正如如下所示，应用一个公有的构造函数进行初始化和一个公共的工厂办法进行公布。

public class ThreadTest {


    public final int id;
    public final String name;
    private final EventListener listener;

    private ThreadTest() {
        id = 1;
        listener = new EventListener() {public void onEvent(Object obj) {System.out.println("id:" + ThreadTest.this.id);
                System.out.println("name:" + ThreadTest.this.name);
            }
        };
        name = "Thread";
    }

    public static ThreadTest getInstance(EventSource<EventListener> source) {ThreadTest safe = new ThreadTest();
        source.registerListener(safe.listener);
        return safe;
    }

}

class EventSource<E> {public void registerListener(E listener) {}}

总结：须要思考线程平安的状况

  • 拜访 共享 的变量或资源
  • 所有依赖 时序 的操作
  • 不同的数据之间存在 捆绑 关系的时候

线程外围九：深入浅出 Java 内存模型的正确姿态

JVM 内存构造、Java 内存模型、Java 对象模型对别

  • JVM 内存构造：和 Java 虚拟机的 运行时区域 无关。
  • Java 内存模型：和 Java 的 并发 编程无关。
  • Java 对象模型：和 Java 对象在 虚拟机中的表现形式 无关。

Java 内存模型是什么

Java Memory Model（JMM）是一组 标准 ，须要各个 JVM 的实现来恪守 JMM 标准，以便于开发者能够 利用这些标准，更不便地开发多线程程序。

如果没有这样的一个 JMM 内存模型来标准，那么很可能通过了不同 JVM 内存模型来标准，那么很可能通过了不同 JVM 的不同规定的重排序后，导致不同的虚拟机上运行的后果不一样。

volatile、synchronized、Lock 等原理都是 JMM

如果没有 JMM，那就须要咱们本人指定书目时候用内存栅栏等，那是相当麻烦的，幸好有 JMM，咱们只须要用 同步工具和关键字 就能够开发并行程序。

JMM 最重要的三点：重排序 、 可见性 、 原子性。

重排序

咱们看上面代码例子：

public class ThreadTest {


    static int a = 0;
    static boolean flag = false;

    public static void main(String[] args) {while (true) {Thread t1 = new Thread(() -> {
                a = 1;
                flag = true;
            });
            Thread t2 = new Thread(() -> {if (flag && a == 0) {System.out.println("---------- 指令重排序 ------------");
                }
            });
            t1.start();
            t2.start();
            a = 0;
            flag = false;
        }
    }
}

运行后果：

---------- 指令重排序 ------------
---------- 指令重排序 ------------

咱们能够看到在 t1 线程外面代码程序和咱们想的并不一样，在有些状况下执行进去的后果是先给 flag 赋值为 true，但 a 还是 0，所以在线程 2 中判断进去之后打印了指令重排序。

由此咱们能够很分明的晓得，代码指令并不是严格依照代码语句的程序执行的。

那为什么须要重排序呢？

因为这样能够进步处理速度

咱们看下图没有重排序是什么样子的：

先 load 一个 a 而后 set 一个 3 保留，b 也同理，最初 load a 加成 4 保留。

然而排序之后就是这个样子：

可见性

咱们看上面代码例子：

public class ThreadTest {

    int i = 0;
    boolean flag = true;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        new Thread(() -> {System.out.println("初始状态为：" + threadTest.flag);
            while (threadTest.flag) {threadTest.i++;}
            System.out.println(threadTest.i);
        }).start();
        Thread.sleep(3000L);
        threadTest.flag = false;
        System.out.println("最初状态为：" + threadTest.flag);
    }
}

运行后果:

咱们明明曾经改为了 false，然而并没有打印进去 i 的值，程序也没有进行。

次要导致的起因其实就是，主线程中批改了 flag，在子线程中不可见。一部分起因是 CPU 高速缓存在极短的工夫内不可见，另外一点即便 flag 曾经同步到了主内存中，然而子线程中还是没有读到 flag。

CPU 高速缓存在极短的工夫内不可见的，一段时间后还是会同步到主内存中，然而 while 是一个循环不停的从主内存中获取 flag 的值，每次都是 true 这是因为 JVM 和 JIT 优化导致的, 办法体中的循环被屡次执行，JIT 将循环体中缓存到了办法区，每次运行间接从办法区中读取缓存，而办法区缓存的 flag=true，导致 while 循环不能被终止。其实就是主线程写和子线程读的起因。

应用 volatile 关键字

public class ThreadTest {

    int i = 0;
    volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        new Thread(() -> {System.out.println("初始状态为：" + threadTest.flag);
            while (threadTest.flag) {threadTest.i++;}
            System.out.println(threadTest.i);
        }).start();
        Thread.sleep(3000L);
        threadTest.flag = false;
        System.out.println("最初状态为：" + threadTest.flag);
    }
}

运行后果：

初始状态为：true
最初状态为：false
1967391405

咱们加上 volatile 后 i 的值打印了进去，程序也失常的完结了。

为什么 volatile 要害能够解决这个问题呢? volatile 如何实现它的语义的呢?

  • 禁止缓存:volatile 变量的拜访控制符会加上 ACC_VOLATILE
  • 对 volatile 变量相干的指令不做重排序

JVM 的标准中，文档对 ACC_VOLATILE 的解释:Declared volatile;cannot be cached.(不可能被缓存)

加上 volatile 后会强制 (flush) 将 flag 的值刷入到主内存中，子线程就能够读取到批改后的值
每个线程都有本人的工作内存，而可能存在 writer-thread 到写入操作，还没有同步到主内存，reader-thread 会从主内存中读取。
volatile 会将写入操作，强制刷入到主内存中。

为什么会有可见性问题

CPU 有多级缓存，导致读的数据过期

  • 高速缓存的容量比主内存小，然而速度仅次于寄存器，所以在 CPU 和主内存之间就多了 Cache 层。
  • 线程间的对于共享变量的可见性问题不是间接由多核引起的，而是由多缓存引起的。
  • 如果所有的外围都只用一个缓存，那么也就不存在内存可见性问题。
  • 每个外围都会将本人须要的数据读到独占缓存中，数据批改后也是写入到缓存中，而后期待刷入到主存中，所以会导致有些外围读取的值是一个过期的值。

JMM 的形象：主内存和本地内存

  • Java 作为高级语言，屏蔽了这些底层细节，用 JMM 定义了一套读写内存数据的标准，尽管咱们不在须要关怀以及缓存和二级缓存的问题，然而 JMM 形象了主内存和本地内存的概念。
  • 这里说的本地内存并不是真的是一块给每个线程调配的内存，而是 JMM 的一个形象。
  • 所有的变量都存储在主内存中，同时每个线程也有本人独立的工作内存，工作内存中的变量内容是主内存中的拷贝。
  • 线程不能间接读写主内存中的变量，而是只能操作本人工作内存中的变量，而后在同步到主内存中。
  • 主内存是多个线程共享的，但线程间不共享工作内存，如果线程间须要通信，必须借助主内存中转换来实现
    所有但共享变量存在于主内存中，每个线程有本人的本地内存，而且线程读写共享数据也是通过本地内存替换的，所以才导致了可见性问题。

Happens-Before 准则

  • Happens-Before 准则是用来解决可见性问题的：在工夫上，动作 A 产生在动作 B 之前，B 保障能看见 A，这就是 Happens-Before。
  • 两个操作能够用 Happens-Before 来确定它们的执行程序：如果一个操作 Happens-Before 于另一个操作，那么咱们说第一个操作对于第二个操作是可见的。
  • 当程序蕴含两个没有被 Happens-Before 关系排序的抵触拜访时，就存在数据竞争，遵循了这个准则，也就意味着有些代码不能进行重排序，有些数据不能缓存。

Happens-Before 的规定有哪些?

  • 单线程准则（Happens-Before 并不影响重排序）
  • 锁操作（解锁前的所有操作，都对加锁后的可见）

  • volatile（批改数据后会立刻刷新到主存，告诉其余线程来更新）

  • 线程启动（在子线程启动的时候，能取得到主线程之前的语句产生的后果）

  • 线程 join（在 join 之后的语句肯定能看到 join 之前所有语句产生的后果）

  • 传递性：如果 hb(A,B)而且 hb(B,C)，那么能够推出 hb(A,C)
  • 中断：一个线程被其余线程 interrupt 时，那么检测中断 (isInterrupted) 或者抛出 InterruptedException 肯定能看到。
  • 构造方法：对象构造方法的最初一行指令 Happens-Before 于 finalize()办法的第一行指令。

  • 工具类的 Happens-Before 准则

    • 线程平安的容器，get 肯定能看到在此之前的 put 等存入操作
    • CountDownLatch
    • Smaphore(信号量)
    • Future
    • 线程池
    • CyclicBarrier

volatile 关键字详解

volatile 是什么？

volatile 是一种 同步机制 ，比 synchronized 或者 Lock 更为 轻量级 ，因为应用 volatile 并不会产生 上下文切换 等开销很大的行为。

如果一个变量被润饰成 volatile，那么 JVM 就晓得这个变量可能会被并发批改。

开销小，那么响应的能力也小，尽管 volatile 是用来同步的保障线程平安的，然而 volatile 做不到 synchronized 那样的原子爱护，volatile 仅在很无限的场景下能力发挥作用。

volatile 的实用场合

不实用：a++

还是间接上代码：

public class ThreadTest implements Runnable {

    volatile int a;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        Thread thread01 = new Thread(threadTest);
        Thread thread02 = new Thread(threadTest);
        thread01.start();
        thread02.start();
        thread01.join();
        thread02.join();
        System.out.println("后果为：" + threadTest.a);
    }

    @Override
    public void run() {for (int i = 0; i < 10000; i++) {a++;}
    }
}

运行后果：

后果为：16639

实用 场合

  • boolean flag，如果一个共享变量从头至尾只被各个线程赋值，而没有其余的操作，那么就能够用 volatile 来代替。synchronized 或者代替原子变量，因为赋值资深是有原子性的，而 volatile 又保障了可见性，所以就足以保障线程平安。

并不是所有 boolean 都能够，如果不是一个明确的值则会有线程平安问题。

boolean flag = true;
private void test(){
    flag = true;  // 平安
    flag = !flag; // 不平安
}
  • 作为刷新之前变量的 触发器

触发器就是充当，之前的操作都是被其余线程可见的，在如下代码中让 b 来充当触发器，当线程 2 读到 b=0 的时候，那么线程 1 的批改必定是对线程 2 可见的。

    int a = 1;
    volatile int b = 2;
    int abc = 1;
    int abcd = 1;

    private void change() {
        abc = 7;
        abcd = 70;
        a = 3;
        b = 0;
    }

    private void print() {if (b == 0) {
            // 当 b = 0 当时候，能够确保 b 之前的所有操作都是可见的
            System.out.println("b=" + b + "a=" + a);
        }
    }

volatile 的两点作用

  1. 可见性：读一个 volatile 变量之前，须要先使相应的本地缓存生效，这样就必须到主内存读取最新值，写一个 volatile 属性会立刻刷入到主内存中。
  2. 指令重排序：解决单例双重锁乱序问题

volatile 小结

  • volatile 修饰符实用于以下场景：某个属性被多个线程共享，其中有一个线程批改了此属性，其余线程能够立刻失去批改后的值，比方 boolean flag，或者作为触发器，实现轻量级同步。
  • volatile 属性的读写操作都是 无锁 的，它不能代替 synchronized，因为他没有提供 原子性 ， 互斥性 。因为无锁，不须要破费工夫在获取锁和开释锁上，所以它是 低成本 的。
  • volatile 只作用于属性，用 volatile 润饰属性，这样编译器就不会对这个属性做指令重排序。
  • volatile 提供了 可见性，任何一个线程对其批改将立马对其余线程可见。volatile 属性不会被线程缓存，始终从主存中读取。
  • volatile 提供了 Happens-Before 保障，对 volatile 变量 v 的写入 Happens-Before 所有其余线程后续对 v 的读操作都是最新的值。
  • volatile 能够使得 long 和 double 的赋值是原子的，后续会讲 long 和 double 的原子性。

原子性

什么是原子性

一系列的操作，要么全副执行胜利，要么全副不执行，不会呈现执行一半的状况，是不可分割的。

Java 中的原子操作有哪些

  • 除了 long 和 double 之外的 根本类型 (int,byte,boolean,short,char,float) 的赋值操作
  • 所有援用 reference 的赋值操作，不论是 32 位的机器还是 64 位机器
  • java.concurrent.Atomic.* 包中所有类的原子操作

long 和 double 的原子性

官网文档的形容: 非原子化解决 double 和 long，出于 Java 编程语言存储器模型的目标，对非易失性 long 或 double 值的单个写入被视为两个独自的写入：每个 32 位半写一个。这可能导致线程从一次写入看到 64 位值的前 32 位，而另一次写入看到第二次 32 位的状况。volatile long 和 double 的写入和读取始终是原子的。对援用的写入和读取始终是原子的，无论它们是实现为 32 位还是 64 位。

在 32 位上的 JVM 上 long 和 double 的操作不是原子的，然而在 64 位的 JVM 上是原子的。

理论开发中：商用 Java 虚拟机中 不会呈现。

原子操作 + 原子操作 != 原子操作

  • 简略地把原子操作组合在一起，并 不能保障 整体仍然具备原子性
  • 比方 ATM 机两次取钱是两次独立的原子操作，然而期间有可能银行卡被借走了，被其余线程打断并批改
  • 全同步的 HashMap 也不齐全平安

synchronized 详解

synchronized是什么？

synchronized 是 Java 中解决并发问题的一种最罕用的办法，也是最简略的一种办法。Synchronized 的作用次要有三个：

  1. 原子性：确保线程互斥的拜访同步代码。
  2. 可见性：保障共享变量的批改可能及时可见，其实是通过 Java 内存模型中的“对一个变量 unlock 操作之前，必须要同步到主内存中；如果对一个变量进行 lock 操作，则将会清空工作内存中此变量的值，在执行引擎应用此变量前，须要从新从主内存中 load 操作或 assign 操作初始化变量值”来保障的。
  3. 有序性：无效解决重排序问题，即“一个 unlock 操作后行产生 (Happen-Before) 于前面对同一个锁的 lock 操作”。

从语法上讲，synchronized 能够把任何一个非 null 对象作为 ” 锁 ”，在 HotSpot JVM 实现中，锁有个专门的名字：对象监视器（Object Monitor）。

synchronized 总共有三种用法：

  1. 当 synchronized 作用在实例办法时，监视器锁（monitor）便是对象实例（this）。
  2. 当 synchronized 作用在静态方法时，监视器锁（monitor）便是对象的 Class 实例，因为 Class 数据存在于永恒代，因而静态方法锁相当于该类的一个全局锁。
  3. 当 synchronized 作用在某一个对象实例时，监视器锁（monitor）便是括号括起来的对象实例。

synchronized 可能保障在 同一时刻 最多只有 一个 线程执行该段代码，以达到保障并发平安的成果。

synchronized 的位置

synchronized 是 Java 的 关键字，被 Java 语言原生反对。

是最根本的互斥同步伎俩。

代码演示：i++ 问题

之前咱们曾经应用过 volatile 来保障在并发环境下后果正确的状况。咱们应用 synchronized 来演示一下。

public class ThreadTest implements Runnable {

    int a;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        Thread thread01 = new Thread(threadTest);
        Thread thread02 = new Thread(threadTest);
        thread01.start();
        thread02.start();
        thread01.join();
        thread02.join();
        System.out.println("后果为：" + threadTest.a);
    }

    @Override
    public synchronized void run() {for (int i = 0; i < 10000; i++) {a++;}
    }
}

运行后果：

后果为：20000

在一个线程拿到锁后，另一个线程只能阻塞期待其余线程开释这把锁，开释了之后他们会进行争抢这把锁，而不是有序性。

也就是说 synchronized 是 非偏心锁。

synchronized 的两个用法

对象锁

包含办法锁（默认锁对象为 this 以后实例对象）和同步代码块锁（本人指定锁对象）。

i++ 问题的另一种对象锁写法：

@Override
public void run() {synchronized (this) {for (int i = 0; i < 10000; i++) {a++;}
    }
}

锁某一个对象：

Object lock = new Object();

@Override
public void run() {synchronized (lock) {for (int i = 0; i < 10000; i++) {a++;}
    }
}

类锁

指 synchronized 润饰动态的办法或者指定锁为 Class 对象。

i++ 问题的类锁写法（Class 对象）：

@Override
public void run() {synchronized (ThreadTest.class) {for (int i = 0; i < 10000; i++) {a++;}
    }
}

i++ 问题的另一品种锁写法（synchronized 加在 static 办法上）：

public class ThreadTest implements Runnable {

    static int a;

    public static void main(String[] args) throws InterruptedException {ThreadTest threadTest = new ThreadTest();
        Thread thread01 = new Thread(threadTest);
        Thread thread02 = new Thread(threadTest);
        thread01.start();
        thread02.start();
        thread01.join();
        thread02.join();
        System.out.println("后果为：" + ThreadTest.a);
    }


    @Override
    public void run() {method();
    }

    private static synchronized void method() {for (int i = 0; i < 10000; i++) {a++;}
    }
}

synchronized 性质

性质一：可重入

什么是可重入？

可重入指的是对立线程的外层函数取得锁之后，内层函数能够间接再次取得该锁。

长处：防止死锁。

粒度：

  • 证实同一个办法是可重入的。
public class ThreadTest {

    int a;

    public static void main(String[] args) {new ThreadTest().method1();}

    private synchronized void method1() {System.out.println(Thread.currentThread().getName()+"进入 method1...");
        if (a == 0) {
            a++;
            method1();}

    }
}

运行后果：

main 进入 method1...
main 进入 method1...

因为这些办法输入了雷同的线程名称，表明即便递归应用 synchronized 也没有产生死锁，证实其是可重入的。

  • 证实可重入的不要求是同一个办法
public class ThreadTest {public static void main(String[] args) {new ThreadTest().method1();}

    private synchronized void method1() {System.out.println(Thread.currentThread().getName() + "进入 method1...");
        method2();}

    private synchronized void method2() {System.out.println(Thread.currentThread().getName() + "进入 method2...");
    }
}

运行后果：

main 进入 method1...
main 进入 method2...
  • 证实可重入的不要求是同一个类中的
public class ThreadTest extends FatherTest {public static void main(String[] args) {new ThreadTest().method1();}

    private synchronized void method1() {System.out.println(Thread.currentThread().getName() + "进入 method1...");
        method2();}


}

class FatherTest {public synchronized void method2() {System.out.println(Thread.currentThread().getName() + "进入父类 method2...");
    }
}

运行后果：

main 进入 method1...
main 进入父类 method2...

性质二：不可中断

什么是不可中断性质？

一旦这个锁曾经被他人取得了，如果我还想取得，我只能抉择期待或者阻塞，直到别的线程 开释 这个锁，如果他人永远不开释锁，那么我只能永远等上来。

加锁和开释锁的原理

每一个 java 对象都能够用作 monitor，monitor 被称为内置锁，线程在进入同步代码块之前会主动获取 monitor lock，并且它在退出同步代码块的时候，会主动开释 monitor lock（无论是失常执行返回还是抛出异样退出）。所以获取 monitor lock 的惟一路径就是进入到 Synchronized 所爱护的办法中。

通过反编译咱们能够看到下图字节码：

这个时候咱们想要的 monitorenter 和 monitorexit 呈现了。

monitorenter 入口只有一个，然而 monitorexit 的进口有多个，因为程序异样也会执行 monitorexit。

可重入原理：减速次数计数器

  • JVM 负责跟踪对象被加锁的次数。
  • 线程第一次给对象加锁的时候，计数器变为 1，每当这个雷同的线程在此对象上再次取得锁时，计数器会递增。
  • 每当工作来到时候，计数器递加，当计数器为 0 的时候，锁被开释。

可见性原理

在开释锁之前肯定会将数据写回主内存

一旦一个代码块或者办法被 synchronized 所润饰，那么它执行结束之后，被锁住的对象所做的任何批改都要在开释之前，从线程内存写回到主内存。也就是说它不会存在线程内存和主内存内容不统一的状况。

在获取锁之后肯定从主内存中读取数据

同样的，线程在进入代码块失去锁之后，被锁定的对象的数据也是间接从主内存中读取进去的，因为上一个线程在开释的时候会把批改好的内容回写到主内存，所以线程从主内存中读取到数据肯定是最新的。

就是通过这样的原理，synchronized 关键字保障了咱们每一次的执行都是牢靠的，它保障了可见性。

退出移动版