Java 多线程高并发编程 笔记（一）

本篇文章主要是总结Java多线程/高并发编程的知识点，由浅入深，仅作自己的学习笔记，部分侵删。

一 . 基础知识点

1. 进程于线程的概念

2.线程创建的两种方式

　　注：public void run（）方法提供了线程实际工作的代码；

　　　　继承Thread类的方法存在单继承的缺陷；

　　　　Runnable的代码可以被多个线程（Thread实例）共享，适合于多个线程处理统一资源的情况；

3. Thread类的常用方法

　　 

4. Java线程正确停止的方法

　　最常用的方法是设置退出旗标（标志），要注意，stop方法不是正确的方法，它会让线程戛然而止，interrupt（）方法也不是正确停止线程的方法，它的初衷并不是用于停止线程；

5. 线程交互：互斥与同步

　　互斥：同一时间只能有一个线程去对临界区进行操作，通过synchronized（intrinsic lock）实现，只有获得lock的线程才能进入synchronized声明的代码块；

　　同步：线程之间的通信机制；当某些条件不具备时线程处于等待状态，条件满足，需要发出消息来唤醒所有线程；通过wait（）/notify（）/notifyAll（）实现。

　　Wait Set：可以理解为线程休息室；

　　共享资源/数据又被称为临界区（Critical Section），当有一个线程想要访问共享资源的时候，首先，他需要获得锁，获得锁后进入我们的临界区进行操作，操作过程中，如果发现某些情况不被满足，将调用锁对象上的wait()方法，此时，该线程释放掉锁资源，然后进入到锁对象上的Wait Set，由于这个线程释放掉了我们的锁资源，使得其他线程可以来竞争多资源，所以其他线程获得锁并进入临界区，同时在锁对象上的wait set中有多条线程在等待条件的满足，当我们的当前运行线程执行完某些操作需要通知等待的线程时，调用notify方法将会唤醒所资源所持有的等待区域中的一条线程，是这条线程有机会去进行竞争CPU资源；或者调用notifyAll方法，这时会使wait set中的所有线程被唤醒，从而使得它们有机会在当前线程离开临界资源释放锁之后去竞争临界资源的锁对象。

6. 线程的生命周期

　　

7. 守护线程

　　Java线程有两类：

　　用户线程：运行在前台，执行具体的任务；程序的主线程，连接网络的子线程等都是用户线程；
　　守护线程：运行在后台，为其他前台线程服务；　

　　守护线程的特点：一旦所有用户线程都结束运行，守护线程会随JVm一起结束工作；
　　守护线程的应用：数据库连接池中的监测线程；JVM虚拟机启动后的监测线程，最常见的是垃圾回收线程；
　　守护线程的设置：通过调用Thread类的setDaemon(true)方法来设置当前的线程为守护线程；
　　注意：setDaemon（true）必须在start（）方法之前调用，否则会抛出IllegalThreadStateException异常；守护线程中产生的新线程也是守护线程；不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑；

二 . 进阶知识点

1. 对象加锁

1.1 使用synchronized关键字对某个对象加锁

 public class T {
     private int count=10;
     private Object o = new Object();
     public void m(){
         synchronized (o){ //任何线程要执行下面代码，必须先拿到o的锁
             count--;
             System.out.println(Thread.currentThread().getName()+"count="+count);
         }//执行完了释放锁
     }
 }

在上面的代码中，锁是自己new的，每次new出一个没有其他功能的对象比较麻烦，所以可以用synchronized（this），代码如下：

 public class T {
     private int count = 10;
     public void m(){
         synchronized (this){
             count--;
             System.out.println(Thread.currentThread().getName()+"count="+count);
         }
         /**
          * 上面的代码可以简写为：
          * public synchronized void m(){
          *      count--;
          *      System.out.println(Thread.currentThread().getName()+"count="+count);
          * }
          * 注意：synchronized 锁定的是对象而不是代码
          */

     }
 }

1.2 synchronized用在静态方法上

　　类中静态方法和静态属性属性是不需要new出对象来访问的，没有new出来，就没有this引用的存在，所以当锁定一个静态方法时，相当于锁定的是当前类的class对象。

 public class T {
     private static int count = 10;
     public synchronized static void m(){ //这里等同于synchronized(packagename.T.class)
         count--;
         System.out.println(Thread.currentThread().getName()+"count="+count);
     }

     public static void nm(){
         synchronized (T.class){ //是class类的对象
             count--;
         }
     }
 }

1.3 锁住线程的run方法

 public class T implements Runnable{
     private int count = 10;
     public synchronized void run(){
         count--;
         System.out.println(Thread.currentThread().getName()+"count="+count);
     }
     public static void main(String[] args){
         T t = new T();//多个线程共同访问一个Runnable对象
         for(int i=0; i<5; i++){
             new Thread(t,"Thread"+i).start();
         }
     }
 }

如果不加synchronized时，count--和打印语句间可能有别的线程执行count--，导致前后数据不一致，加synchronized后方法里的所有语句相当于一个原子操作，只有当run方法执行完了释放锁，下一个线程才能拿到锁执行run方法。

1.4 面试题：同步方法和非同步方法是否可以同时调用？-->可以

 public class T {
     public synchronized void m1(){
         System.out.println(Thread.currentThread().getName()+"m1 start...");
         try {
             Thread.sleep(10000);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"m1 end...");

     }
     public void m2(){
         try{
             Thread.sleep(5000);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"m2");
     }

     public static void main(String[] args){
         T t = new T();
         new Thread(t::m1,"t1").start();
         new Thread(t::m2,"t2").start();
     }
 }

执行结果：

t1m1 start...
t2m2
t1m1 end...

1.5 对业务写方法加锁，对业务读方法不加锁，容易产生脏读

 public class Account {
     String name;
     double balance;
     public synchronized void set(String name,double balance){
         this.name = name;
         try{
             Thread.sleep(2000);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         this.balance = balance;
     }

     public double getBalance(String name){
         return this.balance;
     }

     public static void main(String[] args){
         Account a = new Account();
         new Thread(()->a.set("zhangsan",100.0)).start();
         try{
             TimeUnit.SECONDS.sleep(2);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(a.getBalance("zhangsan"));//0.0

         try{
             TimeUnit.SECONDS.sleep(2);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println(a.getBalance("zhangsan"));//100.0
     }
 }

1.6 一个同步方法可以调用另一个同步方法

一个线程已经拥有某个对象的锁，再次申请时仍然会得到该对象的锁

synchronized获得的锁是可重入的

 public class T {
     synchronized void m1(){
         System.out.println("m1 start");
         try{
             TimeUnit.SECONDS.sleep(1);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         m2();//可调用
     }
     synchronized void m2(){
         try{
             TimeUnit.SECONDS.sleep(2);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println("m2");
     }
 }

1.7 在继承中，子类重写的同步方法可以调用父类的同步方法

 public class T {
     synchronized void m(){
         System.out.println("m start");
         try{
             TimeUnit.SECONDS.sleep(1);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         System.out.println("m end");
     }
     public static void main(String[] args){
         new TT().m();
     }

 }
 class TT extends T{
     synchronized void m(){
         System.out.println("child m start");
         super.m();//可以调用父类的同步方法
         System.out.println("child m end");
     }
 }

1.8 出现异常，默认情况下锁会被释放

 /**
  * 程序在执行过程中如果出现异常，默认情况下锁会被释放
  * 所以在执行并发处理的过程中，有异常要小心，不然可能会发生不一致的情况；
  * 比如，在一个web app处理过程中，多个servlet线程共同访问一个资源
  * 这是如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，
  * 有可能会访问到异常产生时的数据（处理了一半的数据），
  * 因此要非常小心处理同步业务逻辑中的异常
  */

 import java.util.concurrent.TimeUnit;
 public class T {
     int count = 0;
     synchronized void m(){
         System.out.println(Thread.currentThread().getName()+"start");
         while(true){
             count++;
             System.out.println(Thread.currentThread().getName()+"count"+count);
             try{
                 TimeUnit.SECONDS.sleep(1);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
             if(count==5){
                 int i=1/0;//此处抛出异常，锁被释放，要想不被释放，可以在这里进行catch，然后让循环继续

             }
         }
     }
     public static void main(String[] args){
         T t = new T();
         Runnable r = new Runnable(){
             public void run(){
                 t.m();
             }
         };
         new Thread(r,"t1").start();
         try{
             TimeUnit.SECONDS.sleep(3);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         new Thread(r,"t2").start();
     }
 }

2. volatile 关键字

2.1 volatile的可见性

　　 volatile 关键字，使一个变量在多个线程间可见，A B 线程都用到一个变量，java默认是A线程中保存一份copy，这样如果B线程修改了该变量，则A未必知道，使用volatile关键字，会让所有线程都会读到变量的修改值；

　　在下面的代码中，running 是存在于堆内存对象中，当线程t1开始运行的时候，会把running值从内存中读到t1线程工作区，在运行过程中直接使用这个copy并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行

　　volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说 volatile不能代替synchronized；

 public class T {
     volatile boolean running = true;
     void m(){
         System.out.println("m start");
         while(running){

         }
         System.out.println("m end");
     }
     public static void main(String[] args){
         T t = new T();
         new Thread(t::m,"t1").start();
         try{
             TimeUnit.SECONDS.sleep(1);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         t.running = false;
     }
 }

volatile 只保证了原子性，而synchronized既保证可见性有保证原子性，但是synchronized太重了；

2.2 volatile不具有原子性

 /*10个线程分别执行10000次count++，count是对象vna的成员变量，按理来说最终count=100000，
   但是最终每次执行结果都不一样，count一直小于100000，说明volatile不具备原子性*/
 public class VolatileNoAtomic {
     volatile int count = 0;
     void m() {
         for(int i=0; i<10000; i++) {
             count ++ ;
         }
     }
     public static void main(String[] args) {
         VolatileNoAtomic vna = new VolatileNoAtomic();
         List<Thread> threads = new ArrayList<>();
         for (int i=0; i<10; i++) {
             threads.add(new Thread(vna::m, "thread" + i));
         }
         threads.forEach(o->o.start());
         threads.forEach((o)->{
             try {
                 //join()方法阻塞调用此方法的线程,直到线程t完成，此线程再继续。通常用于在main()主线程内，等待其它线程完成再结束main()主线程。
                 o.join(); //相当于在main线程中同步o线程，o执行完了，main线程才有执行的机会
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         });
         System.out.println(vna.count);
     }
 }

2.3 synchronized既保证原子性又保证可见性

 public class SynVisibleAndAtomic {
     int count = 0;
     synchronized void m() {  //m方法加了synchronized修饰，保证了原子性和可见性
         for (int i=0; i<10000; i++) {
             count ++ ;
         }
     }
     public static void main(String[] args) {
         SynVisibleAndAtomic sva = new SynVisibleAndAtomic();
         List<Thread> threads = new ArrayList<>();
         for (int i=0; i<10; i++) {
             threads.add(new Thread( sva::m , "thread-" + i));
         }
         threads.forEach((o)->o.start());
         threads.forEach((o)-> {
             try {
                 o.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         });
         System.out.println(sva.count); //
     }
 }

2.4 面试题：实现一个容器，提供两个方法add，size，线程1添加10个元素到容器，线程2监控元素的个数，当个数为5时，线程2提示并结束

 public class MyContainerVolatile {
     volatile List list = new ArrayList();
     public void add(Object o) {  //add
         list.add(o);
     }
     public int size() {   //size
         return list.size();
     }

     public static void main(String[] args) {
         MyContainerVolatile mcv = new MyContainerVolatile();
         new Thread( () -> {  //该线程负责往list里添加
            for (int i=0; i<10; i++) {
                mcv.add(new Object());
                System.out.print(" add-" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
         },"t1").start();
         new Thread( () -> { //该线程一直监测list的size，直到size=5
             while(true) {  //一直监测着，很浪费CPU
                 if(mcv.size() == 5) {  //此处未加同步，仍然可能会出现t1中又一次++为6了，才break
                     break;
                 }
             }
             System.out.print(" t2结束 ");
         },"t2").start();
     }
 }

上面的代码能解决问题，但t2线程的死循环很浪费CPU，影响性能！更优方法是使用wait和notify，请参看下例：

 public class MyContainerWaitNotify {
     volatile List list = new ArrayList();
     public void add(Object o) {
         list.add(o);
     }
     public int size() {
         return list.size();
     }

     public static void main(String[] args) {
         MyContainerWaitNotify mcwn = new MyContainerWaitNotify();
         final Object lock = new Object();
         new Thread(()->{
             synchronized (lock) {
                 System.out.print(" ***线程t2启动*** ");
                 if (mcwn.size() != 5) {
                     try {
                         lock.wait();  //size不等于5时，就一直在那等着，直到被t1叫醒
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 System.out.print(" ***线程t2结束*** ");
                 lock.notify();  //通知t1继续执行
             }
         }, "t2").start();

         new Thread(()->{
             synchronized (lock) {
                 for(int i=0; i<10; i++) {
                     mcwn.add(new Object());
                     System.out.print(" add-"  + i);
                     if (mcwn.size() == 5) {
                         lock.notify();  //唤醒另一个线程t2，本线程继续执行，直至synchronized包裹的代码块结束或者调用了wait
                         try {
                             lock.wait(); //释放锁，让t2得以执行
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         },"t1").start();
     }
 }

注意：wait会释放锁，但notify不会，本代码会执行到wait或synchronized块结束才释放锁；

但是，上述的方法还是过于繁琐，Java提供了门闩；

使用CountDownLatch（门闩）的await和countdown方法替代wait和notify方法来进行通知：

 public class MyContainerLatch {
     volatile List list = new ArrayList(); //添加volatile，使t2能够得到通知
     public void add(Object o) {
         list.add(o);
     }
     public int size() {
         return list.size();
     }

     public static void main(String[] args) {
         MyContainerLatch mcl = new MyContainerLatch();
         CountDownLatch latch = new CountDownLatch(1);  //当1变成0时，门就开了
         new Thread(() -> {
             System.out.print(" *t2启动* ");
             if (mcl.size() != 5) {
                 try {
                     latch.await();  //等待不需要锁定一个对象
                     //latch.await(5000,TimeUnit.MILLISECONDS); //也可以指定等待时间
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.print(" *t2结束* ");
         },"t2").start();
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         new Thread(()->{
             System.out.print(" *t1启动* ");
             for (int i=0; i<10; i++) {
                 mcl.add(new Object());
                 System.out.print(" add-" + i);
                 if (mcl.size() == 5) {
                     latch.countDown(); //打开门闩，让t2得以执行。调用一次countDown，就减1
                 }
                 try {
                     TimeUnit.SECONDS.sleep(1);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.print(" *t1结束* ");

         },"t1").start();
     }
 }

这样做的好处是通信方式简单，同时也可以指定等待时间。

声明一个CountDownLatch对象latch并设定初始值>0，调用latch.countDown（）使latch值减一，当latch值变为0，门闩打开；
当不涉及同步，只涉及锁定，用synchronized+wait/notify就显得太重了。这时应该考虑CountDownLatch/cyclicbarrier/semephore.

3. 原子变量类（AtomXxx）

　　原子变量最主要的一个特点是所有的操作都是原子的，synchronized关键字也能做到对变量的原子操作，但是成本相对较高，需要获取锁对象，释放锁对象，如果不能获取到锁，还需要阻塞在阻塞队列上进行等待：

 public class Counter {
     private int count;

     public synchronized void addCount(){
         this.count++;
     }
 }

　　上述代码使用synchronized关键字保证变量原子性，简单的count++操作，线程首先需要获得Counter类实例的对象锁，然后完成自增操作，最后释放锁，十分消耗成本，如果不能获取到锁，还需要阻塞线程等；

　　对于这种情况，可以将count变量声明为原子变量，那么对于count的自增操作都可以以原子的方式进行，就不存在脏数据的读取了；

　　原子变量类一共有12个，可以被分为4组：

常用的基于原子操作的方法：

 //基于原子操作，获取当前原子变量中的值并为其设置新值
 public final int getAndSet(int newValue)
 //基于原子操作，比较当前的value是否等于expect，如果是设置为update并返回true，否则返回false
 public final boolean compareAndSet(int expect, int update)
 //基于原子操作，获取当前的value值并自增一
 public final int getAndIncrement()
 //基于原子操作，获取当前的value值并自减一
 public final int getAndDecrement()
 //基于原子操作，获取当前的value值并为value加上delta
 public final int getAndAdd(int delta)
 //还有一些反向的方法，比如：先自增在获取值的等等

下例展示了使用AtomicInteger来实现int类型的原子性操作：

 public class AtomicIntegerTest {
     AtomicInteger count = new AtomicInteger(0);
     void m() {
         for (int i=0; i<10000; i++) {
             count.incrementAndGet(); ////incrementAndGet()-先+1，再返回; getAndIncrement()-先返回，再+1
         }
     }
     public static void main(String[] args) {
         AtomicIntegerTest ait = new AtomicIntegerTest();
         List<Thread> threads = new ArrayList<>();
         for (int i=0; i<10; i++) {
             threads.add(new Thread( ait::m , "thread" + i));
         }
         threads.forEach((o)->o.start());
         threads.forEach((o)->{
             try {
                 o.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         });
         System.out.println(ait.count); //
     }
 }

4. ReentrantLock-重入锁

　　Java中实现锁通常有两种方式，一种是使用synchronized关键字，另一种是Lock：

4.1 ReentrantLock替代synchronized

 public class ReentrantLockTest1 {
     Lock lock = new ReentrantLock();
     void m1() {
         try {
             lock.lock();  //加锁  //相当于synchronized(this)
             for (int i=0; i<10; i++) {
                 TimeUnit.SECONDS.sleep(1);
                 System.out.print(" " + i);
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();  //释放锁
         }
     }
     void m2() {
         lock.lock();  //加锁
         System.out.print(" m2()... ");
         lock.unlock();  //释放锁
     }

     public static void main(String[] args) {
         ReentrantLockTest1 r1 = new ReentrantLockTest1();
         new Thread(r1::m1).start();
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         new Thread(r1::m2).start();
     }
 }

注意：使用reentrantLock必须要手动释放锁，使用syn锁定的话如果遇到异常，jvm会自动释放锁，但Lock必须手动释放锁，因此常在finally中进行锁的释放；

4.2 ReentrantLock可以进行尝试锁定tryLock（）

 public class ReentrantLock3 {
     Lock lock = new ReentrantLock();
     void m1(){
         try{
             lock.lock();
             for(int i=0; i<10;i++){
                 TimeUnit.SECONDS.sleep(1);
                 System.out.println(i);
             }
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally {
             lock.unlock();
         }
     }

     /**
      * 使用trylock进行尝试锁定,不管锁定与否，方法都将继续执行
      * 可以根据tryLock返回值来判断是否锁定
      * 也可以指定tryLock的时间，由于tryLock（time）抛出异常，所以要注意tryLock的处理
      * 必须放到finally中
      */
     void m2(){
         /*
         //第一种方式:
         boolean locked = lock.tryLock();
         //不管拿没拿到锁都将执行
         System.out.println("m2..."+locked);
         if(locked){
             lock.unlock();
         }
         */
         //第二种方式：
         boolean locked = false;
         try{
             //尝试等5秒
             locked = lock.tryLock(5,TimeUnit.SECONDS);
             System.out.println("m2..."+locked);
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             if(locked)
                 lock.unlock();
         }
     }

     public static void main(String[] args){
         ReentrantLock3 r3 = new ReentrantLock3();
         new Thread(r3::m1).start();
         try{
             TimeUnit.SECONDS.sleep(1);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         new Thread(r3::m2).start();
     }
 }

4.3 使用ReentrantLock还可以调用lockInterruptibly()方法，可以对线程interrupt方法做出响应

在一个线程等待的过程中可以被打断

 public class ReentrantLock4 {
     public static void main(String[] args){
         Lock lock = new ReentrantLock();
         Thread t1 = new Thread(()->{
             try{
                 lock.lock();
                 System.out.println("t1 start");
                 TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                 System.out.println("t1 end");
             }catch(InterruptedException e){
                 System.out.println("Interrupted!");
             }finally{
                 lock.unlock();
             }
         });
         t1.start();

         Thread t2 = new Thread(()->{
             boolean locked = false;
             try {
                 lock.lockInterruptibly();
                 System.out.println("t2 start");
                 TimeUnit.SECONDS.sleep(5);
                 System.out.println("t2 end");
             }catch(InterruptedException e){
                 System.out.println("interrupted");
             }finally{
                 if(locked)
                     lock.unlock();
             }
         });
         t2.start();
         try{
             TimeUnit.SECONDS.sleep(1);
         }catch(InterruptedException e){
             e.printStackTrace();
         }
         t2.interrupt();
     }
 }

4.4. ReentrantLock指定为公平锁（谁等的时间长，谁得到锁）

 public class ReentrantLock5 extends  Thread{
     private static ReentrantLock lock = new ReentrantLock(true);//true表示公平锁
     public void run(){
         for(int i=0; i<100; i++){
             lock.lock();
             try{
                 System.out.println(Thread.currentThread().getName()+"获得锁");

             }finally{
                 lock.unlock();
             }
         }
     }
     public static void main(String[] args){
         ReentrantLock5 r5 = new ReentrantLock5();
         Thread th1 = new Thread(r5);
         Thread th2 = new Thread(r5);
         th1.start();
         th2.start();
     }
 }

4.5 面试题：写一个固定容量的同步容器，有put和get方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用：

方法1：使用wait和notify/notifyAll来实现：

 public class MyContainer1<T> {
     final private LinkedList<T> lists = new LinkedList<>();
     final private int MAX =10;
     private int count = 0;

     public synchronized void put(T t){
         while(lists.size()==MAX){
             try{
                 this.wait();
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
         lists.add(t);
         ++count;
         this.notifyAll();//通知消费者线程进行消费
     }
     public synchronized T get(){
         T t = null;
         //为什么用while? wait 99.9%情况下都是和while一起用的
         //
         while(lists.size()==0){
             try{
                 this.wait();
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }
         t = lists.removeFirst();
         count--;
         this.notifyAll();
         return t;
     }

     public static void main(String[] args){
         MyContainer1<String> c = new MyContainer1<>();
         //启动消费者线程
         for(int i=0; i<10; i++){
             new Thread(()->{
                 for(int j=0; j<5; j++){
                     System.out.println(c.get());
                 }
             },"c"+i).start();
         }
         try{
             TimeUnit.SECONDS.sleep(2);
         }catch(InterruptedException e){
             e.printStackTrace();
         }

         //启动生产者线程
         for(int i=0;i<2;i++){
             new Thread(()->{
                 for(int j =0;j<25;j++){
                     c.put(Thread.currentThread().getName()+" "+j);
                 }
             },"p"+i).start();
         }
      }
 }

方法2：使用

使用Lock和Condition的方式可以更加精确地指定哪些线程被唤醒

 public class MyContainer2<T> {
     final private LinkedList<T> lists= new LinkedList<>();
     final private int MAX =20;
     private int count = 0;

     private Lock lock = new ReentrantLock();
     private Condition producer = lock.newCondition();
     private Condition consumer = lock.newCondition();

     public void put(T t){
         try{
             lock.lock();
             while(lists.size()==MAX){
                 producer.await();
             }
             lists.add(t);
             ++count;
             consumer.signalAll();
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             lock.unlock();
         }
     }

     public T get(){
         T t = null;
         try{
             lock.lock();
             while(lists.size()==0){
                 consumer.await();
             }
             t=lists.removeFirst();
             count--;
             producer.signalAll();
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             lock.unlock();
         }
         return t;
     }

     public static void main(String[] args){
         MyContainer2<String> c = new MyContainer2();

         for(int i=0; i<10; i++){
             new Thread(()->{
                 for(int j=0; j<5; j++){
                     System.out.println(c.get());
                 }
             },"c"+i).start();
         }
         try{
             TimeUnit.SECONDS.sleep(2);
         }catch (InterruptedException e){
             e.printStackTrace();
         }

         //启动生产者线程
         for(int i=0;i<2;i++){
             new Thread(()->{
                 for(int j =0;j<25;j++){
                     c.put(Thread.currentThread().getName()+" "+j);
                 }
             },"p"+i).start();
         }
     }
 }

5. 线程局部变量 ThreadLocal

 public class ThreadLocal1 {
     volatile static Person p = new Person();
     public static void main(String[] args){
         new Thread(()->{
             try{
                 TimeUnit.SECONDS.sleep(2);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
             System.out.println(p.name);
         }).start();

         new Thread(()->{
             try{
                 TimeUnit.SECONDS.sleep(1);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
             p.name = "lisi";
         }).start();
     }
 }
 class Person{
     String name  = "zhangsan";
 }

结果为”lisi“

设定为线程局部变量：

 public class ThreadLocal2 {
     static ThreadLocal<Person> tl = new ThreadLocal<>();
     public static void main(String[] args){
         new Thread(()->{
             try{
                 TimeUnit.SECONDS.sleep(2);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
             System.out.println(tl.get());
         }).start();

         new Thread(()->{
             try {
                 TimeUnit.SECONDS.sleep(1);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
         }).start();
     }
     static class Person{
         String name = "zhangsan";
     }
 }

结果为null。