JUC并发编程学习笔记二（狂神）

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量318 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHOU_VIP/article/details/117232276
版权

1、生产者和消费者问题Synchronized版

package com.kuang.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
 * 线程交替执行  A   B 操作同一个变量   num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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


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

// 判断等待，业务，通知
class Data{ // 数字 资源类

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){  //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){ // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }

}

上述方式存在的问题（虚假唤醒）

若有ABCD四个线程，则会出现虚假唤醒

img

 解决办法： if 改为 while，防止虚假唤醒

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，

而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后。

if改为while判断：

package com.kuang.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
 * 线程交替执行  A   B 操作同一个变量   num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

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

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

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


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

// 判断等待，业务，通知
class Data{ // 数字 资源类

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number!=0){  //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){ // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }

}


A=>1
B=>0
C=>1
B=>0
A=>1
B=>0
C=>1
B=>0
A=>1
B=>0
C=>1
B=>0
A=>1
B=>0
C=>1
B=>0
A=>1
B=>0
C=>1
B=>0

2、JUC版的生产者和消费者问题

 查看源码：

package com.kuang.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) {
        Data2 data = new Data2();

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

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

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

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

    }
}

// 判断等待，业务，通知
class Data2{ // 数字 资源类

    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await(); // 等待
    //condition.signalAll(); // 唤醒全部
    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            // 业务代码
            while (number!=0){  //0
                // 等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){ // 1
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程，我-1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

在这里插入图片描述

下面使用Condition精准的通知和唤醒线程

package com.kuang.pc;

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

/**
 * @author 狂神说Java 24736743@qq.com
 * A 执行完调用B，B执行完调用C，C执行完调用A
 */
public class C {

    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{ // 资源类 Lock

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1; // 1A  2B  3C

    public void printA(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            while (number!=1){
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
            // 唤醒，唤醒指定的人，B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBB");
            // 唤醒，唤醒指定的人，c
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            // 业务，判断-> 执行-> 通知
            // 业务，判断-> 执行-> 通知
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBB");
            // 唤醒，唤醒指定的人，c
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}


A=>AAAAAAA
B=>BBBBBBBBB
C=>BBBBBBBBB
A=>AAAAAAA
B=>BBBBBBBBB
C=>BBBBBBBBB
...

8锁现象（关于锁的8个问题）

package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
 * 1、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class Phone{

    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);//加上sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}


synchronized 锁的对象是方法的调用者！
两个方法用的是同一个锁，谁先拿到谁执行！

发短信
打电话
加一个普通方法

package entity;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class Phone{

    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}


hello
发短信
原因：hello 是一个普通方法，不受 synchronized 锁的影响，不用等待锁释放。
---------------------------------------------------------------------
但是如果注掉TimeUnit.SECONDS.sleep(4);
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class Phone{

    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        /*try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        System.out.println("发短信");
    }

    // 这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

发短信
hello
sendSms()先调用先执行
两个对象，两个调用者，两把锁！
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();


package entity;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{
            phone1.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        }).start();
    }
}

// 可视作资源类
class Phone{
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

打电话
发短信
分析：两个对象两把锁，phone2 对象拿到其锁后打电话，phone1 对象拿到其锁后等待 3s 发短信。
如果把 synchronized 方法加上 static 变成静态方法！

（1）我们先来使用一个对象调用两个方法！

答案是：先发短信,后打电话

package entity;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

// Phone3唯一的一个 Class 对象
class Phone3{

    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    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("打电话");
    }


}

（2）如果我们使用两个对象调用两个方法！

答案是：还是先发短信，后打电话

原因是什么呢？ 为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？

原因是：对于static静态方法来说，对于整个类Class来说只有一份，
对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，
如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！
不管多少个对象，对于静态的锁都只有一把锁，
谁先拿到这个锁就先执行，其他的进程都需要等待！


import java.util.concurrent.TimeUnit;

/**
 * 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
 * 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
 */
public class Test3  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

// Phone3唯一的一个 Class 对象
class Phone3{

    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    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("打电话");
    }


}

如果使用一个静态同步方法、一个同步方法、一个对象调用。
打电话
发短信
分析： 因为一个锁的是Class类的模板，一个锁的是对象的调用者。所以不存在等待，直接运行。

package entity;

import java.util.concurrent.TimeUnit;

/**
 * 1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
 */

public class Test1 {
    public static void main(String[] args) {
        Phone4 phone = new Phone4();
        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class Phone4{

    // 静态的同步方法 锁的是 Class 类模板
    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("打电话");
    }

}



如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么？
打电话
发短信
分析：两把锁锁的不是同一东西


import java.util.concurrent.TimeUnit;

/**
 * 1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
 */
public class Test4  {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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


class Phone4{

    // 静态的同步方法 锁的是 Class 类模板
    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("打电话");
    }

}

集合类不安全

List不安全

package com.sjmp.demo04ListUnsafe;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;


//java.util.ConcurrentModificationException

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }

    }
}

ArrayList 在并发情况下是不安全的

会导致java.util.ConcurrentModificationException并发修改异常！
解决办法

package com.sjmp.demo04ListUnsafe;

        import java.util.ArrayList;
        import java.util.List;
        import java.util.UUID;
        import java.util.concurrent.CopyOnWriteArrayList;


//java.util.ConcurrentModificationException

public class ListTest {

    /*
    * 解决 ArrayList 并发修改异常的方案
    * 1.List<String> list = new Vector<>();
    * 2.List<String> list = Collections.synchronizedList(new ArrayList<>());
    * 3.List<String> list = new CopyOnWriteArrayList<>();
    * */
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }

    }
}


// CopyOnWrite 写入时复制  COW  计算机程序设计领域的一种优化策略；
// 多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
// 在写入的时候避免覆盖，造成数据问题！
// 读写分离
// CopyOnWriteArrayList  比 Vector Nb 在哪里？
// Vector使用的是synchronized效率相对相对较低，CopyOnWriteArrayList使用的是lock锁

Set不安全

Set 和 List 同理可得：多线程情况下，普通的 Set 集合是线程不安全的；

解决方案有两种；

  • 使用 Collection 工具类的 synchronized 包装的 Set 类
  • 使用CopyOnWriteArraySet 写入复制的 JUC 解决方案
package com.sjmp.demo04ListUnsafe;

import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;


public class SetTest {
    public static void main(String[] args) {
        /*
        * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
        * 2.Set<String> set = new CopyOnWriteArraySet<>();
        * */

        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

hashSet 底层是什么？

public HashSet() {
    map = new HashMap<>();
}
// add set 本质就是 map key是无法重复的！
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object(); // 不变的值！

Map不安全

默认加载因子是0.75,默认的初始容量是16

在这里插入图片描述

package com.kuang.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

// ConcurrentModificationException
public class MapTest {

    public static void main(String[] args) {
        // map 是这样用的吗？ 不是，工作中不用 HashMap
        // 默认等价于什么？  new HashMap<>(16,0.75);
        // Map<String, String> map = new HashMap<>();
        // 唯一的一个家庭作业：研究ConcurrentHashMap的原理
        Map<String, String> map = new ConcurrentHashMap<>();

        for (int i = 1; i <=30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

    }
}

参考：hashmap原理 

HashMap 这套八股，不得背个十来遍？-KuangStudy-文章

Callable

  • 可以有返回值

  • 可以抛出异常

  • 方法不同，run()/call()

未完待续。。。。

ZHOU_VIP
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC（狂神版）全面总结
qq_45464015的博客
07-19 3064
目录 1、什么是JUC 1、什么是juc（学习方法：官方文档+源码） java.util：java的工具包，包，分类 什么是juc：java.util.concurrent，java工具类下的一个并发功能的包。 Runnable 没有返回值、效率相比入 Callable相对较低! ·两者都属于juc里面 ·但callable可以返回结果，也可以抛出异常 所以比起runable来说，callable有以下特点： 1、有返回值 2、可以抛出异常 3、方法不同，run（），call（） 案例：https:/
【狂神说java juc 20200219 02篇】8锁现象，TimeUnit，线程安全的使用集合 ConcurrentHashMap，Callable,CyclicBarrierr
qq120631157的博客
08-26 346
8锁现象，TimeUnit，线程安全的使用集合 ConcurrentHashMap，CopyOnWriteArrayList，Callable,CyclicBarrierr，CountDownLatch，Semaphore
JUC底层的详细学习(狂神JUC笔记)(全网最全)---8锁问题 集合类问题 Callable
weixin_43886282的博客
04-23 176
8锁现象 如何判断锁的是谁！锁到底锁的是谁？ 锁会锁住：对象、Class 深刻理解我们的锁 问题1：多个线程使用同一把锁-顺序执行 package com.whf.juc.lock8; /** * @ClassName Test1 * @Description Test1 * @Author 德鲁大叔 * @Date 2021/1/14 16:17 * @Version 1.0 */ import java.util.concurrent.TimeUnit; /** * 8锁就是关于锁的
狂神JUC——8锁现象彻底理解锁
黄坤的博客
06-02 888
1-2锁 package com.company.lock_8; /** * 8锁问题，就是关于锁的8个问题！，判断锁的是谁 */ import java.util.concurrent.TimeUnit; /** * 1.标志情况下，两个线程先打印，发短信？ 打电话？ * 2.sendSms延迟4秒，两个线程先打印，发短信？ 打电话？ */ public class Lock_1To2 { public static void main(String[] args) throw.
2020-11-22
qq_29461579的博客
11-22 119
Synchronized 锁得问题1 package com.thread; import java.util.concurrent.TimeUnit; /** * 打印的信息 一定是 先发短信后打电话 */ public class Test1 { public static void main(String[] args) { //创建对象 Phone phone = new Phone(); //下面两个线程的调用者都是 对
JUC高并发编程详细讲解 狂神笔记pdf 从入门到入坟 请与狂神视频配套使用
12-17
通过深入学习狂神的笔记和配套视频，你可以更全面地掌握这些高级特性，从而提升你的并发编程技能。在B站搜索“遇见狂神说同步课程”，可以找到相应的学习资源，结合实践，你的并发编程能力将得到显著提升。
juc-study编程笔记.md
07-06
学习狂神说的juc编程的笔记
狂神JUC并发笔记大全+Linux等资料
08-07
"狂神JUC并发笔记大全"可能详细解析了这些工具的使用方法和场景，帮助开发者深入理解并发控制的策略。 【Linux操作系统】 Linux是一种广泛应用于服务器和嵌入式系统的开源操作系统，其稳定性和灵活性深受程序员喜爱...
JUC并发编程.md
01-28
JUC并发编程学习笔记，狂神说
狂神说JUC代码狂神说JUC代码
09-11
【狂神说JUC代码】是一系列专注于Java并发编程（JUC，Java Util Concurrency）的教程或笔记，旨在帮助开发者深入理解并掌握Java平台上的并发处理机制。JUC是Java标准库中的一组高级并发工具类，为多线程环境下的程序...
再探JUC-8锁现象
qq_21793443的博客
03-21 428
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
java 内存锁_详解Java中synchronized关键字的死锁和内存占用问题
weixin_39883091的博客
02-12 402
先看一段synchronized 的详解：synchronized 是 java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，当一个...
Java并发编程知识点总结（四）——Synchronized实现原理以及优化
XHHP
09-04 915
synchronized原理 我们可以知道线程的安全问题主要来自于Java内存模型的设计，也就是主内存和各工作内存之间而导致的内存可见性问题，以及重排序导致的问题。 synchronized关键字可以使得线程依次排队操纵共享变量。但是这种机制会导致效率比较低下，并发程度低。 下面我们就具体来看一下synchronized关键字 （二）、synchronized实现原理 2.1 synchroized的作用范围...
Java并发编程(三)——管程：使用悲观锁的思想解决多线程并发中的共享问题
qq_40438165的博客
03-05 308
一、共享带来的问题 \quad当多个线程访问一个共同的资源时，会发生线程安全问题。假设有共享变量i=0，有两个任务，任务1对该变量进行+1操作，任务2对该变量进行-1操作。假设线程t1对i进行+1操作，但还未来得及保存，此时i=0，时间片就切换给线程2，此时线程2又对i进行-1操作并保存，此时i=-1，t2线程结束，时间片给t1，t1将上次未保存的结果1给i，最终输出i=1。按理说i最后等于0，但是由于多个线程操作共享资源，导致了线程安全问题。例如下面程序，返回结果就可能是：[-10000,10000]中任
Java代码解决生产者---消费者问题（两种方法）
热门推荐
阿顾的博客
09-11 1万+
本文通过两种方法解决生产者--消费者问题，思想都是通过锁的竞争进行资源的消耗或者生产，如果有疑问或者写的不好的地方可以留言沟通（代码中都作了详细的注释） 目录 方法一：synchronized, wait, notify  1.1 资源 1.2 消费者 1.3 生产者 1.4 测试代码 方法二：lock, condition, await, signal 2.1 资源 2.2 消...
同步方法（Synchronized Methods）
平凡
07-05 3368
java编程语言提供两种基本的同步方式：同步方法和同步代码块，其中比较复杂的同步代码块会在下一节当中讨论，这一节主要是讲解同步方法。   为了实现方法同步，只要简单的将关键字synchronized添加到方法的声明处，如：public class SynchronizedCounter{ private int c = 0; public synchronized void incre
配置Java开发环境
Broken_x的博客
07-10 1600
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 441
【代码】java集合工具类。
黑马juc并发编程md笔记
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ZHOU_VIP

您的鼓励将是我创作最大的动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值