【JUC多线程学习】线程、并发与并行、Synchronized与Lock、八锁问题

最新推荐文章于 2022-07-28 19:32:06 发布
最新推荐文章于 2022-07-28 19:32:06 发布
阅读量544 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adminguojieBin/article/details/123670331
版权

JUC多线程

java默认有几个线程？

2个 一个是main 一个是GC（垃圾回收）。

java自己可以开启线程吗？

Java不可以开启线程 ，只能通过本地方法调用，Java无法直接操作硬件。

并发与并行

并发：同一时间间隔 多个线程交替执行

并行：多个线程同时执行

线程有6个状态：

  • NEW 新生
  • RUNNABLE 运行
  • BLOCKED 阻塞
  • WATING 等待
  • TIMED_WATING 超时等待
  • TEMINATED 终止

wait和sleep的区别

1、来自不同的类

wait来自Object

sleep来自Thread

2、关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放。

3、使用的范围不同

wait必须在同步代码块中

sleep可以在任何地方

4、是否需要捕获异常

wait不需要捕获异常

sleep必须要捕获异常

锁

传统Synchronized

不加锁的情况：

请添加图片描述

结果会乱序

给sale方法加上锁

请添加图片描述

结果正常。

public class saleTicketDemo01 {
    public static void main(String[] args) {
        //并发： 多线程操作同一个资源类，把资源类丢入线程
        final Ticket ticket = new Ticket();

        new Thread(()->{//lambda表达式 (参数)->{}
            for (int i=0;i<50;i++)
                ticket.sale();
        },"A").start();

        new Thread(()->{
            for (int i=0;i<50;i++)
                ticket.sale();
        },"B").start();

        new Thread(()->{
            for (int i=0;i<50;i++)
                ticket.sale();
        },"C").start();

    }
}

class Ticket{
    //票的数量
    private int num = 30;

    //卖票的操作
    public synchronized void sale(){
        if(num>0)
            System.out.println("卖出第"+(30-num+1)+"张票,还剩"+(--num)+"票");
    }
}

Lock锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class saleTicketDemo02 {
    public static void main(String[] args) {
        //并发： 多线程操作同一个资源类，把资源类丢入线程
        final Ticket2 ticket = new Ticket2();

        new Thread(()->{//lambda表达式 (参数)->{}
            for (int i=0;i<50;i++)
                ticket.sale();
        },"A").start();

        new Thread(()->{
            for (int i=0;i<50;i++)
                ticket.sale();
        },"B").start();

        new Thread(()->{
            for (int i=0;i<50;i++)
                ticket.sale();
        },"C").start();

    }
}

class Ticket2{
    //票的数量
    private int num = 30;
    private Lock lock = new ReentrantLock();
    //卖票的操作
    public void sale(){
        lock.lock();//上锁
        try{
            if(num>0)
                System.out.println("卖出第"+(30-num+1)+"张票,还剩"+(--num)+"票");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();//解锁
        }

    }
}

Synchronized和Lock的区别

1、Synchronized是java内置的关键字，Lock是一个java的类

2、Synchronized 无法判断获取锁的状态 Lock可以判断是否获取到了锁

3、Synchronized 会自动释放锁， Lock必须要手动释放锁，如果不释放锁，死锁

4、Synchronized 线程1（获得锁）、线程2（等待，傻傻的等待） Lock锁不一定会等待下去

5、Synchronized 可重入锁不可以中断，非公平； Lock 可重入的，可以判断锁，可以自己设置公不公平

6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码。

生产者消费者问题

传统Synchronized实现

public class demo01 {

    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }

}

//信号量 资源类
class Data{
    private int num = 0;

    //生产者
    public synchronized void increment() throws InterruptedException {
        if(num!=0){
            //等待
            this.wait();
        }
        num++;
        System.out.println(num);
        //唤醒
        this.notifyAll();
    }
    //消费者
    public synchronized void decrement() throws InterruptedException {
        if(num==0){
            //等待
            this.wait();
        }
        num--;
        System.out.println(num);
        //唤醒
        this.notifyAll();
    }
}

存在的问题

两个线程没有问题，多个线程就会出现问题

防止虚假唤醒，等待需要放在循环中

将if 改为while判断

JUC版的生产者消费者

通过lock 获得 conditon

condition.await() 等待

condition.signalAll() 唤醒全部

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class demo02 {

    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }

}

//信号量 资源类
class Data2{
    private int num = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    //生产者
    public  void increment()  {
        lock.lock();
        try{
            while(num!=0){
                //等待
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //唤醒
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    //消费者
    public synchronized void decrement(){
        lock.lock();
        try{
            while(num==0){
                //等待
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            //唤醒
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

问题：线程乱序的状态

要使它能够有序的执行 A B C D

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class demo03 {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data3{
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while(num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAA");
            num=2;
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while(num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBB");
            num=3;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while(num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCC");
            num=1;
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

八锁问题

  • 锁的对象是方法的调用者
  • 不是同步方法不受锁定的影响
  • static静态方法 类一加载就有了 锁的是Class类模板 （唯一的）
import java.util.concurrent.TimeUnit;

//1，标准情况下，两个线程先打印  发短信 还是  打电话？   发短信
//2，标准情况下，发短信方法sleep 4s 两个线程先打印  发短信 还是  打电话？   发短信
public class test01 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();

    }
}

class Phone{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

因为锁的对象 是 方法的调用者， 两个方法用的是同一个锁。谁先拿到就谁先执行

import java.util.concurrent.TimeUnit;

//3，增加一个普通方法，两个线程先打印  发短信 还是  hello？   hello
public class test02 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.hello();
        }).start();

    }
}

class Phone2{

    public synchronized void sendSms(){
        try {
            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");
    }
}

因为普通方法没有锁，不是同步方法，不受锁的影响

import java.util.concurrent.TimeUnit;

//4,两个对象 都是同步方法  先打印  发短信 还是  打电话？   打电话
public class test02 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();

    }
}

class Phone2{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
    
}

因为现在是两个对象，发短信锁的是phone1对象，打电话锁的是phone2对象，是两把锁

import java.util.concurrent.TimeUnit;

//5,两个静态同步方法  先打印  发短信 还是  打电话？   发短信
public class test03 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();

        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();

    }
}
//只有唯一的一个Class对象
class Phone3{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

因为static 静态同步方法 锁的是Class类模板，所以发短信方法先拿了，打电话只能等待

import java.util.concurrent.TimeUnit;

//6,两个静态同步方法，两个对象  先打印  发短信 还是  打电话？   发短信
public class test03 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象只有一个Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();

    }
}

class Phone3{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

}

static同步方法锁的是Class ，只有一把锁 所以phone1先拿了，先打印发短信

import java.util.concurrent.TimeUnit;

//7,一个普通同步方法，一个静态同步方法，  先打印  发短信 还是  打电话？   打电话
public class test04 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone = new Phone4();

        new Thread(()->{
            phone.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone.call();
        }).start();

    }
}

class Phone4{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

因为这里是两把锁，静态同步方法锁的是Class 普通同步方法锁的是调用者

import java.util.concurrent.TimeUnit;

//8,一个普通同步方法，一个静态同步方法，两个对象  先打印  发短信 还是  打电话？   打电话
public class test04 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            phone1.sendSms();
        }).start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        }).start();

    }
}

class Phone4{

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

}

与7同理，两个用的不是同一个锁

A_Freeze
关注
专栏目录
Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4877
Java高并发编程实战系列，打造精品专栏。
JUC并发多线程进阶
早上真起不来的博客
06-09 336
笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/ JUC并发多线程进阶 1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：不会通过普通的线程代码 Thread 来实现 Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.exe Music.exe；数据+代码+pcb 一个进程可
sleep()和wait()的区别及wait方法的一点注意事项
ach9443的博客
08-05 274
一.查看API sleep是Thread类的方法，导致此线程暂停执行指定时间，给其他线程执行机会，但是依然保持着监控状态，过了指定时间会自动恢复，调用sleep方法不会释放锁对象。 当调用sleep方法后，当前线程进入阻塞状态。目的是让出CPU给其他线程运行的机会。但是由于sleep方法不会释放锁对象，所以在一个同步代码块中调用这个方法后，线程虽然休眠了，但其他线程无法访问它的锁对象...
怎么区分Sleep和wait的
weixin_43499219的博客
09-09 312
Sleep和wait的区别 1、这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。 2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为
synchronized与Lock的区别
qq_58003121的博客
04-04 877
1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类； 2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁； 3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手动释放锁（unlock()方法释放锁），否则容易造成线程死锁； 4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2
JUC多线程学习个人笔记
最新发布
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
JUC并发编程（一） --- 多线程回顾，Synchronized和Lock锁，Condition线程通信，八锁问题
化身强盗的博客
01-06 336
1、JUC简介 JUC是java.util.concurrent的缩写，即concurrent包下的所有东西，非常重要 在学习JUC前需要对Java多线程进行回忆并补充 2、线程和进程 进程和线程 详见操作系统 进程：就是一个正在运行的程序实例，进程是线程的容器 线程：一个程序中不同的功能可能由不同的线程并行执行，例如：打开QQ，你这边和A聊天，那边和B聊天 对java而言：java默认有2个线程：main线程和gc线程 基类：Thread，Runnable，Callable 对于Java而言，
"深入理解JUC多线程编程：线程池、并发集合和原子操作
在学习JUC多线程编程的过程中，我们会接触到一些基本概念和技术。比如，锁是一种重要的同步机制，可以保证多线程访问共享资源的安全性；并发是一种多对一的关系，多个线程同时竞争一个资源；并行是一种多对多的关系...
Synchronized与Lock 区别
qq_17586173的博客
08-31 126
synchronized Java 内置的关键字；Lock 是一个Java 类。 synchronized 无法判断获取锁的状态；Lock 可以判断是否获取到锁。 synchronized 会自动释放锁；Lock 必须手动释放锁，如果不释放锁，将会造成死锁。 synchronized 线程1（获取锁，阻塞了）线程2（等待，一直等待）；Lock 锁就不一定待定下去。 synchronized 可重入锁，不可以中断，非公平锁；Lock 可重入锁，可以判断锁，是否公平锁（可以设置）。 synchronz
wait 与 sleep 区别
zjt980452483的博客
09-17 173
共有四条不同点： 1.来自不同的类 wait() 方法属于Object类，sleep()方法属于Thread类； 2. 资源的释放(锁的释放) wait()方法会释放CPU执行权给其他的线程，而自身进入等待池中等待；sleep()方法会占用CPU，不让出CPU的执行权。也可以解释为sleep没有释放锁，而wait()释放了锁。 （通常wait() 不会加时间进行限制，需要等待其他线程调用...
高频面试题
qq_55624813的博客
10-16 3318
目录 1.集合 1.1.Collection和Collections的区别 1.2. LIst 与 Set 的区别 1.3. Set内存放的元素为什么不可以重复，内部是如何保证和实现的？ 1.4. ArrayList 与 LinkedList 区别 1.5. Arraylist与LinkedList,Map默认空间是多少； 1.6. ArrayList 与 Vector 区别 ; 1.7.HashSet 和 HashMap 区别 ; 1.8.HashMap 和 Hasht...
Synchronized与lock的区别
qq_40432604的博客
03-07 329
1、Synchronized 内置的Java关键字， Lock 是一个Java类 2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁 3、Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁 4、Lock 的使用更加灵活，可以有响应中断、有超时时间等；而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，直到获取到锁； 5、Synchronized 可重入锁，不可以中断的，非公平；Lock ，可
synchronized和lock两种锁的比较
一朵纯洁的小白花的博客
01-24 507
两者区别： 1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类 2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁 tryLock方法 3.synchronized会自动释放锁(a线程执行完同步代码会释放锁;b线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁 4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待
synchronized锁分析
xad707348125的专栏
07-19 5070
一、   引言 JAVA是一门极易入门的语言，这一点尤其表现在JAVA中对象锁的使用和多线程编程上。所谓对象锁，就是可以直接在JAVA的任意Object加锁（synchronized），也可以在通过任意Object进行线程的阻塞（Object.wait()）和唤醒（Object.notify() or Object.notifyAll()），这种面向对象的锁与C系中的Mutex和Semaphor
synchronized锁简单分析
maomao的博客
07-28 1409
有关锁升级的一些面试话术整理
使用synchronized，如何判断是不是同一个锁。
yaotai8135的博客
05-16 2471
先来看一下 == 和 equals 的区别：java中默认的equals方法实现如下：public boolean equals(Object obj) { return (this == obj); }值类型，用==判断相等性。对象引用的话，==判断引用指向的对象是否是同一个。==是判断两个变量或实例是不是指向同一个内存空间。 equals是判断两个变量或实例所指向的内存空间的值是不是相...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值