JUC并发编程入门

1.什么是JUC

java.util.concurrent(并发的)

2.线程与进程

进程:一个程序,例如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 */ } } } // 本地方法,底层的c++,java无法直接操作硬件 private native void start0();

并发、并行

并发编程:并行、并发
并发:多线程操作同一个资源
cpu一核,模拟出多条线程,天下武功,唯快不破,快速交替
并行:多个线程同时执行
并发编程的本质:充分利用cpu的资源

线程有几个状态

 public enum State {         // 新生         NEW,          // 运行         RUNNABLE,          // 阻塞         BLOCKED,          // 等待         WAITING,          //  超时等待         TIMED_WAITING,          // 终止         TERMINATED; 

wait、sleep的区别

1.来自不同的类
wait => Object
sleep => Thread
2.关于锁的释放
wait会释放锁,sleep睡觉了,抱着锁睡觉,不会释放!
wait: 释放锁
sleep: 不释放锁
3.使用的范围是不同的
wait: 必须在同步代码块儿
sleep: 在哪都能执行
4.是否需要捕获异常
wait: 不需要捕获异常
sleep: 必须要捕获异常

3.Lock锁(重点)

传统package com.coderzpw.demo; // 基本买票例子 /** * 正在的多线程开发,公司中的开发 */ public class SaleTicketDemo01 { public static void main(String[] args) { // 并发: 多线程操作同一个资源类,把资源类丢进线程 final Ticket ticket = new Ticket(); // @FunctionalInterface 函数式接口,jdk1.8 lambda表达式 (参数)->{代码} new Thread(()->{ for (int i=1; i<20; i++){ ticket.sale(); } },"A").start(); new Thread(()->{ for (int i=1; i<20; i++){ ticket.sale(); } },"B").start();new Thread(()->{ for (int i=1; i<20; i++){ ticket.sale(); } },"C").start(); } } // synchronized class Ticket{ private int number = 50; // 买票的方式 public synchronized void sale(){ if (number>0){ System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票,剩余"+number+"张票"); number--; } } }

lock接口
实现类1:ReentrantLock(可重入锁)
实现类2:ReentrantReadWriteLock -> ReadLock(读-写锁)
实现类3:ReentrantReadWriteLock -> WriteLock(读-写锁)

package com.coderzpw.demo;  import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  public class SaleTicketDemo02 {     public static void main(String[] args) {         // 并发: 多线程操作同一个资源类,把资源类丢进线程         final Ticket2 ticket2 = new Ticket2();          // @FunctionalInterface 函数式接口,jdk1.8 lambda表达式 (参数)->{代码}         new Thread(()->{             for (int i=1; i<20; i++){                 ticket2.sale();             }         },"A").start();         new Thread(()->{             for (int i=1; i<20; i++){                 ticket2.sale();             }         },"B").start();new Thread(()->{             for (int i=1; i<20; i++){                 ticket2.sale();             }         },"C").start();     } }  /**  *  lock三部曲  *  1. new ReentrantLock()  *  2. lock.lock();         // 加锁  *  3. lock.unlock();       // 解锁  */ class Ticket2{     private int number = 50;     Lock lock = new ReentrantLock();     // 买票的方式     public synchronized void sale(){         lock.lock();        // 加锁         try {             // 业务代码             if (number>0){                 System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票,剩余"+number+"张票");                 number--;             }         }catch (Exception e){             e.printStackTrace();         }finally {             lock.unlock();  // 解锁         }     } } 

JUC并发编程入门
公平锁: 排队,先来后到
非公平锁: 可以插队 (默认)

Synchronized 和 Lock的区别

  1. Synchronized 内置的java关键字; Lock 是一个java接口
  2. Synchronized 无法判断获取锁的状态; Lock可以判断是否获取到锁
  3. Synchronized 会自动释放锁; Lock必须手动释放锁,否则就会死锁
  4. Synchronized 线程1(获取锁,阻塞)、线程2(等待,傻傻的等); Lock锁就不会一直等下去
  5. Synchronized 可重入锁,不可以中断的,非公平锁; Lock,可重入锁,可以判断锁状态,公平与否可以手动设置(默认非公平)
  6. Synchronized 适合锁少量的代码同步问题; Lock适合锁大量的同步代码块

锁是什么?如何判断锁的是谁?

4.生产者与消费者

面试的:单例模式、排序算法、生产者和消费者、死锁

生产者与消费者问题 Synchronized 版
JUC并发编程入门

package com.coderzpw.demo.pc;  /**  *  线程之间的通信问题: 生产者和消费者问题! 等待唤醒、通知唤醒  *  线程交替执行 A B C D 操作同一个变量 coin =0  *  A coin +1  *  B coin -1  * 	C coin -1  * 	D coin +1  */ public class A {     public static void main(String[] args) {         Data data = new Data();          new Thread(()->{    // 这个线程执行 +1             for (int i=0; i<5; i++){                 try {                     data.increment();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"A").start();          new Thread(()->{    // 这个线程执行 -1             for (int i=0; i<5; i++){                 try {                     data.decrement();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"B").start();          new Thread(()->{    // 这个线程执行 -1             for (int i=0; i<5; i++){                 try {                     data.decrement();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"C").start();          new Thread(()->{    // 这个线程执行 +1             for (int i=0; i<5; i++){                 try {                     data.increment();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"D").start();      } }  class Data{// 数字 资源类     private int coin = 0;      // +1     public synchronized void increment() throws InterruptedException {         while(coin!=0){  // 这里必须要有while ,如果用if的话,当其他地方使用notifyAll()方法后该线程会直接唤醒,         //当该线程抢到锁之后线程就不会再判断是否等待的条件了(所以要用while一直判断),即coin是否=0 就直接调用后面的方法,这时就是不应该         //被唤醒的线程被唤醒了,就会造成线程不安全的现象(这种现象被称为虚假唤醒)             // 等待             this.wait();         }         coin++;         System.out.println(Thread.currentThread().getName()+"=>>"+coin);         // 通知其他线程,我+1完毕了         this.notifyAll();     }      // -1     public synchronized void decrement() throws InterruptedException {         while(coin==0){             // 等待             this.wait();         }         coin--;         System.out.println(Thread.currentThread().getName()+"=>>"+coin);         // 通知其他线程,我-1完毕了         this.notifyAll();     } } 

如果用if判断执行结果:
JUC并发编程入门
如果用while判断执行结果:
JUC并发编程入门
虚假唤醒
当一个条件满足时,很多线程都被唤醒了,但是只有其中部分是有用的唤醒,其它的唤醒都是无用功
比如说买货,如果商品本来没有货物,突然进了一件商品,这是所有的线程都被唤醒了
,但是只能一个人买,所以其他人都是假唤醒,获取不到对象的锁

JUC版本的生产者和消费者问题
JUC并发编程入门

代码演示

package com.coderzpw.demo.pc;  import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  public class B {   public static void main(String[] args) {         Data1 data1 = new Data1();         new Thread(()->{    // 这个线程执行 +1             for (int i=0; i<5; i++){                 try {                     data1.increment();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"A").start();          new Thread(()->{    // 这个线程执行 -1             for (int i=0; i<5; i++){                 try {                     data1.decrement();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"B").start();          new Thread(()->{    // 这个线程执行 -1             for (int i=0; i<5; i++){                 try {                     data1.decrement();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"C").start();          new Thread(()->{    // 这个线程执行 +1             for (int i=0; i<5; i++){                 try {                     data1.increment();                 } catch (InterruptedException e) {                     e.printStackTrace();                 }             }         },"D").start();     }  } class Data1{// 数字 资源类     private int coin = 0;     // 建一个锁对象     Lock lock = new ReentrantLock();     Condition condition = lock.newCondition();     //        condition.await();        等同于原来的wait方法        等待     //        condition.signalAll();    等同于原来的notifyAll方法   唤醒全部     //        condition.signal();       等同于原来的notify方法      唤醒某一个      // +1     public  void increment() throws InterruptedException {         // 业务代码写在try里,解锁写在finally里保证无论怎样都能执行解锁,避免死锁         try {             lock.lock();    // 加锁             while (coin!=0){                 // 等待                 condition.await();             }             coin++;             System.out.println(Thread.currentThread().getName()+"=>>"+coin);             // 通知其他线程,我+1完毕了             condition.signalAll();         } catch (Exception e) {             e.printStackTrace();         } finally {             lock.unlock();  // 解锁         }      }      // -1     public synchronized void decrement() throws InterruptedException {         try {             lock.lock();             while (coin==0){                 // 等待                 condition.await();             }             coin--;             System.out.println(Thread.currentThread().getName()+"=>>"+coin);             // 通知其他线程,我-1完毕了             condition.signalAll();         } catch (Exception e) {             e.printStackTrace();         } finally {             lock.unlock();         }     } } 
JUC并发编程入门

精准唤醒 通过不同的condition对象进行精准唤醒

package com.coderzpw.demo.pc;  import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;  /**  * 要求 A执行完调用B,B执行完调用C,C执行完调用A  */ public class C {     public static void main(String[] args) {         Data2 data2 = new Data2();         new Thread(()->{             for (int i=0; i<10; i++){                 data2.printA();             }         },"A").start();          new Thread(()->{             for (int i=0; i<10; i++){                 data2.printB();             }         },"B").start();          new Thread(()->{             for (int i=0; i<10; i++){                 data2.printC();             }         },"C").start();     } } class Data2{ // 资源类  Lock     public Lock lock = new ReentrantLock();                 // 锁对象     public Condition condition1 = lock.newCondition();       // 锁监视器1     public Condition condition2 = lock.newCondition();       // 锁监视器2     public Condition condition3 = lock.newCondition();       // 锁监视器3     private int num = 1;                                     // 1A  2B  3C      public void printA(){         try {             lock.lock();             // 业务, 判断-> 执行 -> 通知             while(num!=1){                 // 等待                 condition1.await();             }             System.out.println(Thread.currentThread().getName()+"=>>AAAAAA");             // 唤醒,唤醒指定的人,B             num = 2;             condition2.signal();          } catch (Exception e) {             e.printStackTrace();         } finally {             lock.unlock();         }     }     public void printB(){         try {             lock.lock();             // 业务, 判断-> 执行 -> 通知             while(num!=2){                 // 等待                 condition2.await();             }             System.out.println(Thread.currentThread().getName()+"=>>BBBBBB");             // 唤醒,唤醒指定的人,B             num = 3;             condition3.signal();          } catch (Exception e) {             e.printStackTrace();         } finally {             lock.unlock();         }     }     public void printC(){         try {             lock.lock();             // 业务, 判断-> 执行 -> 通知             while(num!=3){                 // 等待                 condition3.await();             }             System.out.println(Thread.currentThread().getName()+"=>>CCCCCC");             // 唤醒,唤醒指定的人,B             num = 1;             condition1.signal();         } catch (Exception e) {             e.printStackTrace();         } finally {             lock.unlock();         }     } } 
JUC并发编程入门

5、8锁现象(锁的八个问题)

如何判断锁的是谁? 对象、Class

package com.coderzpw.demo.lock8;  import java.util.concurrent.TimeUnit;  /**  * 8锁,就是关于锁的8个问题  * 1. 同一个phone,标准情况下,两个线程先打印“发短信”还是“打电话”    答:先发短信 后打电话  * 2. 同一个phone,sendSms延迟4秒,两个线程先打印什么?             答:先发短信 后打电话   (因为锁的是同一个对象,且调用sleep方法并不会释放锁)  */ public class Test1 {     public static void main(String[] args) {         Phone phone = new Phone();         new Thread(()->{             try {                 TimeUnit.SECONDS.sleep(4);  // 先睡眠4秒             } catch (InterruptedException e) {                 e.printStackTrace();             }             phone.sendSms();         },"A").start();          try {             TimeUnit.SECONDS.sleep(1); // 线程休眠一秒   JUC版本的休眠 类似于Thread.sleep()         } catch (InterruptedException e) {             e.printStackTrace();         }          new Thread(()->{             phone.call();         },"B").start();     } } class Phone{      // synchronized 锁的对象是方法的调用者!     // 两个方法用的同一个锁,谁先拿到谁执行     public synchronized void sendSms(){         System.out.println("发短信");     }     public synchronized void call(){         System.out.println("打电话");     } } 
package com.coderzpw.demo.lock8;  import java.util.concurrent.TimeUnit;  /**  * 3、同一个phone,增加了一个普通方法后,先打印“发短信”还是“hello”?      答:先hello后发短信  *   (因为hello没有加synchronized,没有加锁,不是同步方法,不会受锁的影响。)  * 4、 不同phone,两个对象,两个同步方法,先发短信还是先打电话?           答:先打电话,后发短信    (因为这是两个不同的对象,是不同的两把锁)  */ public class Test2 {     public static void main(String[] args) {         // 两个对象         Phone2 Phone21 = new Phone2();         Phone2 phone22 = new Phone2();         new Thread(()->{ Phone21.sendSms(); },"A").start();          try {             TimeUnit.SECONDS.sleep(1); // 线程休眠一秒   JUC版本的休眠 类似于Thread.sleep()         } catch (InterruptedException e) {             e.printStackTrace();         }          new Thread(()->{ phone22.call(); },"B").start();     } } class Phone2{      // synchronized 锁的对象是方法的调用者!     // 两个方法用的同一个锁,谁先拿到谁执行     public synchronized void sendSms(){         try {   // 调用sendSms的时候 要先睡眠4秒             TimeUnit.SECONDS.sleep(4);         } catch (InterruptedException e) {             e.printStackTrace();         }         System.out.println("发短信");     }     public synchronized void call(){         System.out.println("打电话");     }     public void hello(){         System.out.println("hello");     } } 
package com.coderzpw.demo.lock8;   import java.util.concurrent.TimeUnit;  /**  * 5、增加两个静态的同步方法,只有一个对象,先打印“发短信”还是“打电话”?        答:先发短信后打电话  * 6、两个对象!增加两个静态的同步方法,只有一个对象,先打印“发短信”还是“打电话”?   答:先发短信后打电话(因为锁的是一个类,一个已经占用了类,另一个就只能阻塞)  */ public class Test3 {     public static void main(String[] args) {         // 两个对象的Class类模板只有一个,static,锁的是Class         Phone3 phone31 = new Phone3();         Phone3 phone32 = new Phone3();         new Thread(()->{ phone31.sendSms(); },"A").start();          try {             TimeUnit.SECONDS.sleep(1); // 线程休眠一秒   JUC版本的休眠 类似于Thread.sleep()         } catch (InterruptedException e) {             e.printStackTrace();         }          new Thread(()->{ phone32.call(); },"B").start();     } }  // Phone3唯一的一个class对象 class Phone3{      // synchronized 锁的对象是方法的调用者!     // static 静态方法     // 类一加载就有了! 锁的是Class模板     public static synchronized void sendSms(){         try {   // 调用sendSms的时候 要先睡眠4秒             TimeUnit.SECONDS.sleep(4);         } catch (InterruptedException e) {             e.printStackTrace();         }         System.out.println("发短信");     }     public static synchronized void call(){         System.out.println("打电话");     }     public void hello(){         System.out.println("hello");     } } 
package com.coderzpw.demo.lock8;   import java.util.concurrent.TimeUnit;  /**  * 7、一个静态同步方法,一个普通同步方法,一个对象,先打印哪一个?         答:先打电话,后发短信 (因为这两个方法锁的东西是不一样的,一个是类,一个是对象。所以互不影响)  * 8、一个静态同步方法,一个普通同步方法,两个对象,先打印哪一个?         答:先打电话,后发短信  (原因同上)  */ public class Test4 {     public static void main(String[] args) {         Phone4 phone41 = new Phone4();         Phone4 phone42 = new Phone4();         new Thread(()->{ phone41.sendSms(); },"A").start();          try {             TimeUnit.SECONDS.sleep(1); // 线程休眠一秒   JUC版本的休眠 类似于Thread.sleep()         } catch (InterruptedException e) {             e.printStackTrace();         }          new Thread(()->{ phone42.call(); },"B").start();     } }  // Phone4 class Phone4{      // static 静态同步方法 锁的是Class类模板     public static synchronized void sendSms(){         try {   // 调用sendSms的时候 要先睡眠4秒             TimeUnit.SECONDS.sleep(4);         } catch (InterruptedException e) {             e.printStackTrace();         }         System.out.println("发短信");     }     // 普通同步方法、锁的是调用者     public synchronized void call(){         System.out.println("打电话");     } } 

6、集合类线程不安全(ArrayList、HashSet、HashMap都是线程不安全的)

JUC并发编程入门
这图上的集合类之间的关系 不包括java.util.concurrent里面的类

1. List

public class ListTest {     public static void main(String[] args) {         List<String > list = new ArrayList<>();          for (int i=0; i<20; i++){             new Thread(()->{                 list.add(UUID.randomUUID().toString().substring(0,5));                 System.out.println(list);             },String.valueOf(i)).start();         }     } } 
JUC并发编程入门
package com.coderzpw.demo.unsafe; import java.util.*; import java.util.concurrent.CopyOnWriteArrayList;  /**  * @author 小虎牙  *  * 1. 故障现象  *    java.util.ConcurrentModificationException   并发修改异常  * 2. 导致原因  *  * 3. 解决方法  *  (1) 使用List<String > list = new Vector<>(); Vector是线程安全的(其源码内部的对集合的读写方法都加了synchronized关键字)  *  (2) 使用List<String> list = Collections.synchronizedList(new ArrayList<>())    Collections是集合工具类 Collection是集合的上层接口  *  (3) 使用JUC下面的CopyOnWriteArrayList类(写时赋值集合)  List<String> list = new CopyOnWriteArrayList<>(); 内部源码只在写方面加了锁  * 4. 优化建议(同样的错误不犯两次)  */ public class ListTest {     public static void main(String[] args) {         listNotSafe();     }     public static void listNotSafe(){         List<String> list = new CopyOnWriteArrayList<>(); //Collections.synchronizedList(new ArrayList<>());//new Vector<>(); //new ArrayList<>();         for (int i=0; i<20; i++){             new Thread(()->{                 list.add(UUID.randomUUID().toString().substring(0,5));                 System.out.println(list);             },String.valueOf(i)).start();         }     } } 

CopyOnWriteArrayList类
JUC并发编程入门
2. set

package com.coderzpw.demo.unsafe;  import java.util.Set; import java.util.UUID; import java.util.concurrent.CopyOnWriteArraySet;  public class SetTest {     public static void main(String[] args) {          setNotSafe();     }     public static void setNotSafe(){         Set<String> set = new CopyOnWriteArraySet<String>();         for (int i=0; i<20; i++){             new Thread(()->{                 set.add(UUID.randomUUID().toString().substring(0,5));                 System.out.println(set);             },String.valueOf(i)).start();         }     } } 

3.map

package com.coderzpw.demo.unsafe;  import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap;  public class MapTest {     public static void main(String[] args) {         mapNotSafe();     }     public static void mapNotSafe(){         Map map = new ConcurrentHashMap();         for (int i=0; i<20; i++){             new Thread(()->{                 map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));                 System.out.println(map);             },String.valueOf(i)).start();         }     } } 

版权声明:玥玥 发表于 2021-03-28 4:41:10。
转载请注明:JUC并发编程入门 | 女黑客导航