阳哥多线程JUC--1

最新推荐文章于 2021-08-02 11:12:40 发布
最新推荐文章于 2021-08-02 11:12:40 发布
阅读量412 收藏 2
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38705074/article/details/106464202
版权

1、lamda表达式

括号开始、右箭头、大括号结束

 package com.ntuzy.juc_01.zf;

public class lamdaDemo {
    @FunctionalInterface
    interface  LambdaAcount{
        int add(int x, int y);

    }
    public static void main(String[] args) {
        LambdaAcount lambdaAcount = (x,y)->{return x+y;};
        int account = lambdaAcount.add(3,5);
        System.out.println(account);
    }
}

2、线程通信(普遍方法)

多线程口诀：
1.线程操作资源类
2.判断，执行逻辑，通知
3.防止多行程的虚假唤醒，用while解决，不能用if判断
4.标志位(Condiction精准唤醒)

package com.ntuzy.juc_01.zf;
class Air {
    private int num = 0;

    public synchronized void increment() throws InterruptedException {
        //判断
        while(num != 0) {
            this.wait();
        }
        //执行逻辑
        num++;
        //通知
        System.out.println(Thread.currentThread().getName() +":  "+ num);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        //判断
        while(num == 0) {
            this.wait();
        }
        //执行逻辑
        num--;
        //通知
        System.out.println(Thread.currentThread().getName() +":  "+ num);
        this.notifyAll();
    }
}

public class ThreadWaitNotifyDemo {


    public static void main(String[] args) {
        Air air = new Air();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        air.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

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


        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        air.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

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


    }
}

3、线程通信（新版方法）

package com.ntuzy.juc_01.zf;

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

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

public class ThreadWaitNotifyDemo {


    public static void main(String[] args) {
        Air air = new Air();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    air.increment();
                }

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


        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    air.decrement();
                }

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

    }
}

4、用Condiction精准唤醒线程

package com.ntuzy.juc_01.zf;

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

class ShareResource {
    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();
            }
            num = 2;
            System.out.println(Thread.currentThread().getName());
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

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

    }

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

    }
}

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

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

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

5、八锁问题
在这里插入图片描述在这里插入图片描述

package com.ntuzy.juc_01.zf;

import java.util.concurrent.TimeUnit;

class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("---sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("---sendSMS");
    }

    public void hello() {
        System.out.println("---hello");
    }
}

public class Lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "name").start();
        Thread.sleep(100);
        new Thread(() -> {
            //phone.sendSMS();
//            phone.hello();
//            phone2.sendSMS();
//            phone.sendSMS();
            phone2.sendSMS();
        }, "name").start();

    }


}

6、CopyOnWriteList()、CopyOnWriteArraySet、ConcurrentHashMap并发

在这里插入图片描述

7、Callable接口

package com.ntuzy.juc_01.zf;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {

        return 1024;
    }
}
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        MyThread myThread = new MyThread();
        FutureTask future = new FutureTask(myThread);
         new Thread(future,"A").start();
         new Thread(future,"B").start();
        System.out.println(future.get());
    }
}

8、CountDownLatch倒计时开始

package com.ntuzy.juc_01.zf;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count  = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                count.countDown();
                System.out.println(Thread.currentThread().getName() + "离开教室");
            }, String.valueOf(i)).start();
        }
        count.await();
        System.out.println(Thread.currentThread().getName() + "班长关门走人");
    }
}

9、CyclicBarrier加法计数器

package com.ntuzy.juc_01.zf;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 聚齐7颗龙珠召唤神龙
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("召唤神龙");
        });
        for (int i = 0; i < 19; i++) {
            int finalI = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "召唤第：" + finalI + "龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            }, String.valueOf(i)).start();
        }

    }
}

10、SemaPhore信号灯

package com.ntuzy.juc_01.zf;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 3个车位，7个人的车抢位,出去一个进来一个
 */
public class SemaPhoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 7; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到了" + finalI + "车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName() + "离开了" + finalI + "车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }

    }

}
帅哥阿飞
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
尚硅谷JUC百度云连接
02-15
尚硅谷JUC百度云连接
阳哥JUC并发编程之AQS后篇全网最详细源码笔记
最新发布
sakura的博客
12-21 820
此文档记录2022年B站学习尚硅谷阳哥JUC并发编程笔记及代码源码分析，AQS后序笔记的学习，适用于春招面试复习用；同时记录学习记录
JUC与JVM并发编程学习笔记01
AnalogElectronic的博客
01-16 237
JUC（java.util.concurrent) 1.可重入锁多线程售票案例 package com.test.concurrent; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 可重入锁多线程售票案例 */ public class SaleTicketDemo01 { public static void main(String[] args
【尚硅谷/周阳】JUC学习笔记
耿鬼不会笑的博客
04-29 3006
JUC学习笔记【尚硅谷/周阳】 本文章基于B站视频教程【juc 与 jvm 并发编程 Java 必学_阳哥- 尚硅谷】进行整理记录，仅用于个人学习，交流使用。 0.课前引入 1.进程/线程是什么? 进程： 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程： 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系
JUC学习笔记
m0_49039508的博客
05-12 130
JUC的学习笔记 JUC：即java.util.concurrent包里的相关知识 内存不可见性与内存可见性的概念 先来可一个测试结果不可思议的例子，如下代码： public class Demo1 { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); new Thread(myRunnable).start(); // 启动线程 while(true) {
sonar-scanner-cli-3.3.0.1492-windows.zip
06-05
1. **配置环境**：设置SonarQube服务器的URL、项目密钥以及认证信息，这些可以通过环境变量或者在运行扫描时通过命令行参数指定。 2. **初始化扫描**：运行`sonar-scanner`命令，这将启动分析流程。默认情况下，它...
sonar-scanner-cli-3.3.0.1492-macosx.zip
06-05
1. `bin`目录：包含了不同平台的可执行文件，对于macOS，会有对应的可执行脚本，如`sonar-scanner`，开发者可以通过命令行执行这些脚本来启动分析。 2. `lib`目录：存放了SonarScanner运行所需的库文件，这些库文件...
庞恩哥多
02-16
庞恩哥多(Pong-en-godot)是一个使用GDScript编程语言开发的开源游戏项目，其基于著名的经典电子游戏——乒乓球(Pong)。GDScript是Godot游戏引擎内置的一种脚本语言，它易于学习，同时提供了强大的功能，使得开发者...
am-pos-2020-2:2020年塞哥多塞梅多纳峰会上的反洗钱法
03-16
标题中的"am-pos-2020-2:2020年塞哥多塞梅多纳峰会上的反洗钱法"似乎是指一个特定的事件或讨论，可能是在2020年的一次名为“塞哥多塞梅多纳峰会”上，涉及到了反洗钱法律议题。这个标题暗示了这次峰会在金融监管、...
Reto-Domiciolios-JS-01：JavaScript范围合并
02-12
Clam unafunciónllamada“ randomTime”在米拉塞哥多斯国家高尔夫俱乐部和拉格鲁尼亚高尔夫俱乐部1000ms hasta 8000ms。 完成“命令”和“错误”对应的命令。 随机时间。 特塞尔·问题 Corregit la funcion“ ...
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
JVM笔记（阳哥）.zip
09-14
JVM笔记= zip
互联网大厂面试题第二季 尚硅谷阳哥主讲
04-15
尚硅谷阳哥主讲面试题.
cloud2020:springcloud第2季源码-阳哥出品
03-23
cloud2020 springcloud第2季源码-阳哥出品
周阳大神高级+面试经验+Java面试题.txt
03-03
周阳大神高级+面试经验+Java面试题
阳哥多线程JUC--2
weixin_38705074的博客
06-01 306
1、ReadWriteLock读可以多个线程，写只能一个线程，写操作时不能被打断 ```java package com.ntuzy.juc_01.zf; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * */ class MyCa
阳哥JVM笔记
qq_43601023的博客
06-29 408
JVM体系结构 类加载器(快递员)： 只负责加载java文件，编译后的class文件在文件开头有特定的文件表示，将class文件字节码内容从硬盘加载到JVM内存中并将这些内容转换成方法区的运行时数据结构，至于是否可以正常运行由Execution Engine决定。加载class后为模板Class，该模板存放类的结构信息，一个模板可以实例化多个实例 3个classLoader：启动加载器Bootstrap(C++)，扩展加载器Extension(Java)，应用程序类加载器AppClassLoa
JUC基础笔记（尚硅谷周阳JUC的笔记）
dogs的博客
08-02 1928
JUC概述卖票Lambda表达式 概述 juc就是 java.util.concurrent包的首字母 下面又分 并发包、 atomic 和 locks 包 也就是所谓的并发工具类 进程： 是程序的一次执行，拥有独立资源的单位 线程：轻量级线程，共享进程中的内存资源 ，程序调度和分配的基本单位， 更好的使程序并发的执行 并发： 是在程序在宏观上是并行， 实则是交替的执行 并行： 两个程序一起执行，同步执行。 在高内聚低耦合的前端下： 多线程编程的企业级套路 + 模板： * 线程 操作（对外暴露的调用方
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
探针弦对旋转黑洞复杂度的深刻影响：Nambu-Goto术语下的时空行为
核心内容围绕着总作用量展开，这个总作用量由两个关键部分组成：爱因斯坦-希尔伯特（Einstein-Hilbert）项，这是广义相对论的基础，以及南布-哥多（Nambu-Goto）项，它专门用来描述开放弦的运动。南布-哥多方程是弦...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值