JUC并发编程入门

最新推荐文章于 2023-07-10 16:45:52 发布

coderzpw

最新推荐文章于 2023-07-10 16:45:52 发布

阅读量1.3k

点赞数 4

分类专栏： Javase_Javaee 文章标签： java 并发编程多线程

本文链接：https://blog.csdn.net/qq_45464560/article/details/115027420

版权

Javase_Javaee 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1. 什么是JUC

java.util.concurrent(并发的)

2. 线程与进程

进程：一个程序，例如CSDN.exe、QQ.exe等程序的集合；
一个进程往往可以包含多个线程，至少包含一个！

java默认有几个线程？ 2个 main、GC
线程：例如一个Typora进程，里面会包括写入、自动保存（都由线程负责）等线程
对于java而言：Thread、Runnable、Callable
Java真的可以开启线程吗？ 开不了

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而言）
cpu一核，模拟出多条线程，天下武功，唯快不破，快速交替
并行：多个线程同时执行，真正意义上的同时执行（针对于多CPU而言）
并发编程的本质：充分利用cpu的资源

java中线程有几个状态

 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锁（重点）

传统synchronized关键字

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();  // 解锁
        }
    }
}

在这里插入图片描述
公平锁：排队，先来后到
非公平锁：可以插队（默认）

Synchronized 和 Lock的区别

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

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

4. 生产者与消费者

生产者与消费者问题 Synchronized 版

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判断执行结果：
在这里插入图片描述
如果用while判断执行结果：

虚假唤醒：
当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功
比如说买货，如果商品本来没有货物，突然进了一件商品，这是所有的线程都被唤醒了
，但是只能一个人买，所以其他人都是假唤醒，获取不到对象的锁

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();
        }
    }
}

在这里插入图片描述

精准唤醒通过不同的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();
        }
    }
}

在这里插入图片描述

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都是线程不安全的）

在这里插入图片描述
这图上的集合类之间的关系不包括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();
        }
    }
}

在这里插入图片描述

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类
在这里插入图片描述
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();
        }
    }
}

coderzpw

关注

4
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
5
评论
JUC并发编程入门

1.什么是JUCjava.util.concurrent(并发的)2.线程与进程进程：一个程序，例如CSDN.exe、QQ.exe等程序的集合；一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程？ 2个 main、GC线程：例如一个Typora进程，里面会包括写入、自动保存（都由线程负责）等线程对于java而言：Thread、Runnable、CallableJava真的可以开启线程吗？开不了public synchronized void start() {
复制链接

扫一扫