javase-thread-210313-01

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量76 收藏
点赞数
分类专栏： javase 文章标签： java 多线程 javase thread
白光一
本文链接：https://blog.csdn.net/FlyUp__/article/details/118378415
版权

javase-thread-210313-01

  • 线程同步
  • 死锁
  • Lock
  • 线程通信
    • 生产者/消费者模式01（管城法）
    • 生产者/消费者模式02（信号灯法）
  • 线程池

线程同步

关键字  synchronized

​ 并发：同一个对象被多个线程同时操作

Demo01
public class Demo08_ThreadUnsafe01 {
    public static void main(String[] args) {
        Station station = new Station();
        new Thread(station,"路人A").start();
        new Thread(station,"路人B").start();
        new Thread(station,"路人C").start();
    }
}

class Station implements Runnable{
    private int ticket = 100;
    boolean flag = true;

    @Override
    public void run() {
        while (flag){
            buyTicket();
        }
    }

    // 同步方法
    // 加上synchronized变成同步方法    现在锁的this     默认对象是this
    private synchronized void buyTicket(){
        if(ticket <= 0){
            System.out.println("票已卖完");
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticket-- +"张票");
    }
}
Demo02
public class Demo08_ThreadUnsafe02 {
    public static void main(String[] args) {
        Account account = new Account(150,"bgy");
        new Thread(new Bank(0,50,account),"A").start();
        new Thread(new Bank(0,150,account),"B").start();
        new Thread(new Bank(0,150,account),"C").start();
        new Thread(new Bank(0,150,account),"D").start();
    }
}

class Account{
    int sumMoney;
    String name;

    public Account(int sumMoney, String name) {
        this.sumMoney = sumMoney;
        this.name = name;
    }
}

class Bank implements Runnable{

    Account account;
    int nowMoney;
    int drawMoney;

    public Bank(int nowMoney,int drawMoney,Account account){
        this.nowMoney = nowMoney;
        this.drawMoney = drawMoney;
        this.account = account;
    }

    @Override
    public void run() {

        //  同步块，可以监视任何对象
        //  锁的对象就是变化的量，，，所以这个例子要锁住account,而不是Bank
        synchronized (account){
            if(account.sumMoney <= drawMoney){
                System.out.println("余额不足");
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 取钱
            account.sumMoney = account.sumMoney - drawMoney;
            System.out.println("还剩余额"+account.sumMoney);

            // 目前我有多少钱
            nowMoney = nowMoney + drawMoney;
            System.out.println(Thread.currentThread().getName() + "我现在手里有" + nowMoney);
        }
    }

Demo03

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

public class Demo08_ThreadUnsafe03 {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               synchronized (list){
                   list.add(Thread.currentThread().getName());
               }
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }
}
CopyOnWriteArrayList
CopyOnWriteArrayList   是一个线程安全的集合

import java.util.concurrent.CopyOnWriteArrayList;

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        Thread.sleep(3000);

        System.out.println(list.size());
    }
}

死锁

产生死锁的四个条件：
	1. 互斥条件：一个资源每次只能被一个进程使用
	2. 请求与保持条件：一个进程因请求资源而阻塞是，对已获得的资源保持不放
	3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
	4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
	
只要破坏以上任意一个或多个条件就能避免死锁的发生
Demo01(造成死锁)
public class Demo01_DeadLock01 {
    public static void main(String[] args) {
        new GoOut(1,"路人甲").start();
        new GoOut(0,"路人乙").start();
    }
}

// 需要穿的衣服
class Cloth{ }

// 需要穿的鞋子
class Shoes{ }

//  选择搭配
class GoOut extends Thread{

    // static修饰，，确保只有一件衣服，一双鞋子
    static Cloth cloth = new Cloth();
    static Shoes shoes = new Shoes();

    int choose;
    String userName;

    public GoOut(int choose, String userName) {
        this.choose = choose;
        this.userName = userName;
    }

    @Override
    public void run() {
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 穿搭
    public void makeUp() throws InterruptedException {

        /*
            目前情况会造成死锁，，双方都拿着锁，都不释放锁
        */

        if (choose == 1){
            synchronized (cloth){       // 得到衣服的锁
                System.out.println(this.userName+"获得衣服的锁");

                Thread.sleep(1000);

                synchronized (shoes){       // 得到鞋子的锁
                    System.out.println(this.userName+"获得鞋子的锁");
                }
            }

        }else{
            synchronized (shoes){       // 得到鞋子的锁
                System.out.println(this.userName+"获得鞋子的锁");

                Thread.sleep(1000);

                synchronized (cloth){       // 得到衣服的锁
                    System.out.println(this.userName+"获得衣服的锁");
                }
            }
        }
    }
}

Demo02(解决)

public class Demo01_DeadLock02 {
    public static void main(String[] args) {
        new GoOut02(1,"路人甲").start();
        new GoOut02(0,"路人乙").start();
    }
}

// 需要穿的衣服
class Cloth02{ }

// 需要穿的鞋子
class Shoes02{ }

//  选择搭配
class GoOut02 extends Thread{

    // static修饰，，确保只有一件衣服，一双鞋子
    static Cloth cloth = new Cloth();
    static Shoes shoes = new Shoes();

    int choose;
    String userName;

    public GoOut02(int choose, String userName) {
        this.choose = choose;
        this.userName = userName;
    }

    @Override
    public void run() {
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 穿搭
    public void makeUp() throws InterruptedException {

        /*
            解决死锁
        */

        if (choose == 1){
            synchronized (cloth){       // 得到衣服的锁       sleep方法不会释放锁，，同步代码块结束后释放锁
                System.out.println(this.userName+"获得衣服的锁");

                Thread.sleep(1000);
            }

            // 放到外面
            synchronized (shoes){       // 得到鞋子的锁
                System.out.println(this.userName+"获得鞋子的锁");
            }

        }else{
            synchronized (shoes){       // 得到鞋子的锁
                System.out.println(this.userName+"获得鞋子的锁");

                Thread.sleep(1000);
            }

            // 放到外面
            synchronized (cloth){       // 得到衣服的锁
                System.out.println(this.userName+"获得衣服的锁");
            }
        }
    }
}

Lock

	Lock是显示锁（手动开启关闭锁），，，synchronized是隐式锁，出了作用域自动释放
	
	Lock只有代码块锁，，synchronized有代码块锁和方法锁
	
	使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（拥有更多的子类）
	
	优先使用：
		Lock > 同步代码块 > 同步方法
		同步代码块：已经进入到了方法体，分配了相应的资源
		同步方法：在方法体之外
Demo
import java.util.concurrent.locks.ReentrantLock;

public class Demo02_Lock implements Runnable{
    private int ticket = 100;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        getTicket();
    }

    public void getTicket() {
        while (true){
            try{
                // 加锁
                lock.lock();

                if(ticket <= 0){
                    System.out.println("票已售空");
                    break;
                }

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "获得第" + ticket-- +"张票");
            }finally {
                // 解锁
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        Demo02_Lock demo = new Demo02_Lock();
        new Thread(demo,"线程A").start();
        new Thread(demo,"线程B").start();
    }
}

线程通信

	wait()		
		表示线程一直等待，直到其他线程通知，与slee相反，会释放锁
	
	wait(long time)
    	指定等待的毫秒数
    	
	notify()
		唤醒一个处于等待状态的线程
		
	notifyAll()
		唤醒同一个对象上所有调用wait方法的程，优先级别高的线程优先调用
		
以上均为Object类的方法，都只能用在同步方法或同步代码块中，
否则抛出lllegaMonitorStateException
01生产者/消费者模式(管城法)
	生产者/消费者模式 ，，也叫，，管城法
	
	生产者：负责生产数据的模块（可以是方法，对象，线程，进程）
	消费者：负责处理数据的模块（可以是方法，对象，线程，进程）
	缓冲区：消费者不能直接使用生产者的数据，他们之间有一个“缓冲区”
	
	生产者将生产好的数据放入缓冲区，，，消费者从缓冲区拿取数据

public class Demo03_PC01 {
    public static void main(String[] args) {
        Container container = new Container();
        new Consumer(container).start();
        new Product(container).start();
    }
}

// 定义产品
class Chicken{
    int id;

    public Chicken(int i){
        this.id = i;
    }
}

// 1.定义容器
class Container{

    // 定义容器大小
    Chicken[] chickens = new Chicken[10];

    // 定义容器计数器
    int count = 0;

    // 生产者放入产品
    public synchronized void push(Chicken chicken){
        // 判断容器是否满了，，满的话就等待消费者消费
        if (count == chickens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 没满的话，放入产品
        chickens[count]=chicken;
        count++;

        // 这个用来通知消费者消费
        this.notifyAll();
    }

    // 消费者消费产品
    public synchronized Chicken pop(){
        // 判断容器是否是空，，空的话就等待生产者生产
        if (count == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 满的话，消费产品
        count--;
        Chicken chicken = chickens[count];

        // 买完了，通知生产者生产
        this.notifyAll();

        return chicken;
    }
}

// 消费者
class Consumer extends Thread{
    Container containe;

    public Consumer(Container containe){
        this.containe = containe;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + containe.pop().id + "只鸡");
        }
    }
}

// 生产者
class Product extends Thread{
    Container containe;

    public Product(Container containe){
        this.containe = containe;
    }

    @Override
    public void run() {
        for (int i = 1; i < 101; i++) {
            System.out.println("生产了" + i + "只鸡");
            containe.push(new Chicken(i));
        }
    }
}
02生产者/消费者模式(信号灯法)
public class Demo03_PC02 {
    public static void main(String[] args) {
        TV tv = new TV();
        new PeoplePlay(tv).start();
        new PeopleWatch(tv).start();
    }
}

// 创建一个动漫
class TV{
    /*
        规则如下：
            演员表演，观众等待   T
            观众观看，演员等待   F

        不是直播，是录播
    */

    // 节目
    String program;
    // 标志
    boolean flag = true;

    // 表演
    public synchronized void play(String program){

        // 如果为false，，观众观看，演员等待
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("现在的节目是：" + program);

        // 通知观众观看
        this.notifyAll();

        this.program = program;

        this.flag = !this.flag;
    }

    // true，，观众等待，演员表演
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观众正在看：" + program);

        this.notifyAll();
        this.flag = !this.flag;
    }
}

// 表演的人
class PeoplePlay extends Thread{
    TV tv;
    public PeoplePlay(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2 == 0){
                this.tv.play("斗罗大陆");
            }else{
                this.tv.play("化肥就用史丹利！！！！");
            }
        }
    }
}

// 观看的人
class PeopleWatch extends Thread{
    TV tv;
    public PeopleWatch(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}

线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo04_ThreadPool {
    public static void main(String[] args) {

        // 创建线程池
        // newFixedThreadPool  池子大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        TestThread tt = new TestThread();
        service.execute(tt);
        service.execute(tt);
        service.execute(tt);
        service.execute(tt);

        // 关闭连接
        service.shutdown();

    }
}

class TestThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
白光一
关注
专栏目录
JavaSE---日志
白豆五的博客
09-05 415
JavaSE-日志
JavaSE-多线程（4）- CAS
sql2008help的博客
11-13 723
JavaSE-多线程（4）- CAS CAS （CompareAndSwap）举例 例1：在此例中，有 THREAD_COUNT （20）个数量的线程调用 AtomicTest 对象m方法，对属性count进行自增操作，最后在主线程打印count的最终结果为20，由于存在多线程多并发访问count，所以在自增操作前使用synchronized关键字对AtomicTest对象进行了锁定。 package com.hs.example.base.multithread.day01; public class
JavaSE-多线程（9）- Semaphore
sql2008help的博客
11-20 485
JavaSE-多线程（9）- Semaphore 解释semaphore前先看下以下例子： 例1 有10个线程同时执行SemaphoreTest任务，从执行结果可以看出，10个线程是同时执行的，等待一段时间后结束。 package com.hs.example.base.multithread.day01; public class SemaphoreTest implements Runnable { @Override public void run() { try
JavaSE-多线程（11）- LockSupport
sql2008help的博客
11-21 529
JavaSE-多线程（11）- LockSupport 使用LockSupport 类可使线程暂停，请看下例： 例1 线程 t1 执行 LockSupportTest 类run方法，在run方法中，每隔1秒输出一次 i 的值，一共输出10次，在i等于5时暂停线程，主线程睡眠8秒后，调用 activate 方法（实际调用 LockSupportTest 对象即锁的notify方法），t1线程继续执行 package com.hs.example.base.multithread.day01; public
JavaSE-多线程基础-基于多线程的计时器应用
wexin_mylove的博客
03-28 1883
JavaSE的多线程的创建以及对于多线程安全的保护，多线程通信以及对于多线程的应用
JavaSE-进阶-学习笔记-JUC
qq_52668773的博客
04-03 2103
​ 管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。​ 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。（把信号量及其操作原语“封装”在一个对象内部）管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。
JavaSE--线程1
ggyggy10的博客
12-08 6262
JavaSE--线程一、线程的概念二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习
javaSE--多线程2
ggyggy10的博客
12-09 5867
文章目录一、线程的上下文切换1.线程切换存在的问题二、线程安全(同步)问题三、解决线程安全问题--上锁上锁的方法：1.同步方法2.同步代码块3.同步锁synchronize的基本原理锁对象乐观锁和悲观锁乐观锁总结 一、线程的上下文切换 一个CPU内核中同一时间只能运行一个线程或者一行指令，切换到另一个线程的过程称为线程的上下文切换 1.线程切换存在的问题 1.线程切换的时候如何找到上次执行的地方？ 每个线程中都有各自的程序计数器，用于记录上次执行的行数 线程在上下切换时会消耗时间，性能会降低 二、线
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 753
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
javaSE-多线程
Antg的博客
07-07 709
文章目录一.基本概念1.程序,进程,线程2.单核和多核CPU3.并行与并发二.线程的创建方法1.方式一:继承Thread类2.实现Runnable接口3.继承Thread和实现Runnable接口的区别三.多线程的使用1.线程的调度2.线程的优先级3.线程的生命周期4.线程控制5.线程的同步概念三.线程同步1.同步方法2.同步锁机制3.释放锁4.Lock(锁)5.使用线程同步解决上面的售票问题5.1使用synchroinzed代码块5.2使用Lock锁 一.基本概念 1.程序,进程,线程 程序:就是一段静
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **线程的创建方式**：实现Runnable接口和继承Thread类。 - **线程同步**：synchronized关键字、wait/notify机制、Lock接口。 - **线程池**：ExecutorService、ThreadPoolExecutor的使用与配置。 以上仅是...
javase-思维导图.zip
08-04
Java提供了Thread类和Runnable接口来创建和管理线程，同时还有synchronized关键字、wait()、notify()等同步机制，以及并发工具类如Semaphore、CyclicBarrier等，用于在多线程环境下保证数据的一致性。 最后，Java ...
java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结
06-04
interrupted是Thread类的静态方法,里面调用了isTnterrupted方法[currentThread().isInterrupted()],测试当前线程是否已经中断,线程的中断状态由该方法清除 isInterrupted是Thread类的实例方法,不清除中断标志 yield...
面试题总结---javaSE--适用于初学者
07-15
本文将深入解析“面试题总结---javaSE--适用于初学者”这一主题，旨在为初学者提供宝贵的复习资料。 1. **Java基础** - **数据类型**：Java分为基本数据类型（如int、char、boolean等）和引用数据类型（类、接口、...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 69
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 464
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 200
BI商业智能：数据可视化、报表可视化系统。
JDK17新增语法特性
2201_76124988的博客
09-20 807
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 585
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JavaSE中的Thread类详解：启动、命名与优先级设置
"这篇文档主要介绍了Java SE中的Thread类及其常用方法，同时也简述了Java语言的历史、特性以及Java程序的两种主要类型：Applet和Application。Java的平台无关性是其重要特性之一，得益于Java虚拟机（JVM）的支持，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值