线程的学习5

最新推荐文章于 2024-06-12 22:18:06 发布
最新推荐文章于 2024-06-12 22:18:06 发布
阅读量334 收藏
点赞数
分类专栏： 多线程 文章标签： 学习 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57082679/article/details/127706148
版权

并发

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时也带来了访问冲突问题（同一个对象被多个线程同时操作）,即并发问题。并发问题可以通过线程同步来解决，即队列+锁机制。

线程同步

线程同步：其实就是就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程使用。为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可。

示例：买票
package com.xct.test4;
//测试买票（线程不安全）
public class UnSafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket b = new BuyTicket();
        new Thread(b,"张三").start();
        new Thread(b,"李四").start();
        new Thread(b,"黄牛").start();
    }
}

//买票
class BuyTicket implements Runnable{
    //票
    private int ticketNum = 500;
    boolean flag = true;//外部停止的方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //买票的方法
    //同步方法 synchronized 锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNum <= 0){
            flag = false;
            return;
        }
        //模拟网络延时
        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNum--+"张票");
    }
}
示例：取钱
package com.xct.test4;
//测试取钱（线程不安全）
public class UnSafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(1000,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing boyFriend = new Drawing(account,100,"女朋友");
        you.start();
        boyFriend.start();
    }



}

//模拟账户
class Account{
    int money;//余额
    String name;//卡名

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

//模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawMoney;//取了多少钱
    int nowMoney;//现在手里有多少钱

    public Drawing(Account account, int drawMoney, String name) {
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    //synchronized 默认锁的是this

    //取钱
    public  void run() {

        //锁银行的账户
        synchronized (account){
            //判断有没有钱
            if(account.money-drawMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够了");
                return;
            }

            //模拟银行取钱延时(sleep可以放大问题的发生性)
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额=余额-你取的钱
            account.money = account.money-drawMoney;
            //你手里的钱=你手里的钱+取得钱
            nowMoney = nowMoney+drawMoney;

            System.out.println(account.name+"余额为"+account.money);
            System.out.println(this.getName()+"手里的钱为"+nowMoney);
        }

    }
}
示例：线程不安全的集合：ArrayList
package com.xct.test4;

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

//不安全的集合 ArrayList
public class UnSafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        //放大问题的发生性
        Thread.sleep(1000);

        //输出list的长度
        System.out.println(list.size());
    }
}
小结：
1. 同步方法：用synchronized修饰需要被多个线程操作的方法。
2. synchronized(obj){}称为同步代码块。obj称为同步监视器。
3. 同步方法锁的是this，就是这个对象本身，同步方法有弊端：方法里面需要修改的内容才需要锁，锁的太多，浪费资源。
4. sleep可以放大问题的发生性。
补充：JUC安全类型的集合 CopyOnWriteArrayList
package com.xct.test4;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                copyOnWriteArrayList.add(Thread.currentThread().getName());
            }).start();
        }

        //放大问题的发生性
        Thread.sleep(1000);
        System.out.println(copyOnWriteArrayList.size());
    }
}

死锁

多个线程互相抱着对方需要的资源，然后形成僵持状态。

产生死锁的条件
  1. 互斥条件：一个资源每次智能被一个进程使用。
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不得强行剥夺。
  4. 循环等待条件：若干个进程之间形成一种头尾相接的循环等待资源关系。
示例：
package com.xct.test5;
//测试死锁问题（两个女孩化妆，互相抱着对方的资源，形成僵持状态）
public class TestSynchronized {
    public static void main(String[] args) {
        MakeUp m1 = new MakeUp(0,"小红");
        MakeUp m2 = new MakeUp(1,"小明");
        m1.start();
        m2.start();
    }
}

//口红
class LipStick{

}

//镜子
class Mirror{

}

//化妆类
class MakeUp extends Thread{
    //每份资源只有一份，用static
     static LipStick lipStick = new LipStick();
     static Mirror mirror = new Mirror();
    private int choice; // 每个女孩的选择
    private String girlName;//女孩的名字

    public MakeUp(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

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

    //化妆的方法
    private void makeUp() throws InterruptedException {
        if(choice == 0){
            synchronized (lipStick){
                System.out.println(this.girlName+"持有口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后想获取镜子的锁
                    System.out.println(this.girlName+"持有镜子的锁");
                }
            }


        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"持有镜子的锁");
                Thread.sleep(2000);
                synchronized (lipStick){//两秒钟后想获取口红的锁
                    System.out.println(this.girlName+"持有口红的锁");
                }
            }

        }
    }
}

Lock锁（JUC包下）

ReentrantLock(可重入锁)类实现了Lock。

示例：
package com.xct.test5;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

    //定义票数
    private int tickNums = 10;

    //定义lock锁
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            //开启lock锁
            try {
                lock.lock();
                if(tickNums > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(tickNums--);
                }else{
                    break;
                }
            }finally {
                //关闭锁
                lock.unlock();
            }

        }

    }
}

synchonized与Lock的对比

  1. Lock是显示锁，需要手动开启和关闭锁。
  2. synchronized是隐式锁，出了作用域自动释放。
  3. Lock只有代码块锁，synchronized有代码块锁和方法锁。

线程通信

线程通信的两种方式：

  1. 管程法：生产者将生产好的数据放入缓冲区，消费者从缓冲区拿数据。
  2. 信号灯法：使用标志位 boolean flag = true.
示例：管程法
package com.xct.test5;
//测试线程通信1   使用缓冲区  管程法
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Provider(synContainer).start();
        new Consumer(synContainer).start();
    }
}

//生产者
class Provider extends Thread{
    SynContainer synContainer;

    public Provider(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    //生产

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synContainer.push(new Product(i));
            System.out.println("生产了"+i+"个产品");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer synContainer;

    public Consumer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第"+synContainer.pop().id+"个产品");
        }
    }
}

//产品
class Product{
    int id;//产品编号

    public Product(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{

    //容器大小
    Product[] products = new Product[10];
    //容器计算器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product){
        // 如果已满，等待消费者消费
        if(count == products.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            //如果容器大小未满，放入产品
            products[count] = product;
            count++;

            //可以通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Product pop(){
        //判断是否消费
        if(count == 0){
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果消费,拿出产品
        count--;
        Product pro = products[count];

        //拿出后，通知生产者生产
        this.notifyAll();
        return pro;
    }
}

//运作
class RunUp implements Runnable{

    @Override
    public void run() {

    }
}
示例：信号灯法
package com.xct.test5;
//测试线程通信2  设置标志位  信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者  演员
class Player extends Thread{
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    //演员表演
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                tv.play("快乐大本营正在播放");
            }else{
                tv.play("广告中");
            }
        }
    }
}

//消费者 观众
class Watcher extends Thread{
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    //观众观看

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

//产品 节目
class TV{
     String voice;//节目
    private boolean flag = true;//标志位


    //演员表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员演了"+voice);
        //通知观众观看
        this.notifyAll();
        //更新节目与标志位
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观众观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了"+voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

线程池

线程池就是提前创建若干个线程，如果有任务需要处理，线程池里的线程就会处理任务，处理完之后线程并不会被销毁，而是等待下一个任务。由于创建和销毁线程都是消耗系统资源的，所以当你想要频繁的创建和销毁线程的时候就可以考虑使用线程池来提升系统的性能。
JDK5起提供了线程池相关的API：ExecutorService和Executors。

示例：
package com.xct.test5;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool  参数大小为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭服务
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
BUG忠实爱好者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程生命周期
weixin_43178406的博客
09-14 3万+
本文主要介绍了线程生命周期，希望能对学习线程的同学们有所帮助。 文章目录 1. 综述 2. 线程的生命周期
C#学习笔记之线程安全
无所谓的专栏
11-30 3569
待续
详细学习PyQt5中的多线程
weixin_49520696的博客
12-02 2833
本节将探讨为何在PyQt5应用中采用多线程和并发编程是必要的，并引出接下来将要深入讨论的主题：多线程的基本概念、并发编程的需求以及如何与PyQt5框架集成。在这个场景中，使用多线程可以提高用户体验，保持应用的响应性。多线程和并发在图形用户界面应用程序中的应用是至关重要的，可以提高应用的性能、响应性和用户体验。在 PyQt5 应用中，异步编程和协程可以提高程序的效率，尤其是在处理涉及网络请求或其他 I/O 操作的任务时。在Python中，多线程是一种同时执行多个线程的机制，每个线程都是独立的执行流。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
pyqt5多线程使用方法及学习案例（QThread）
小屋
03-24 3732
在使用pyqt5的过程中，会存在界面卡死的现象，为了优化改善，可以利用多线程来解决此类问题。可以实现信号与槽在多个线程中的相互传递数据。 用法很简单，创建一个进程类，不同触发时刻分别调用即可。 参考案例一：来源《PyQT5线程：多线程(QThread)，线程锁(QMutex)》 实现两个线程来在工作台显示不同打印信息。 from PyQt5.Qt import (QApplication, QWidget, QPushButton, QThread,QMutex,
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
Python 多线程学习
Herishwater的博客
05-10 3474
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
多线程学习思维导图
weixin_44448094的博客
03-09 1538
线程学习笔记
weixin_44192849的博客
01-03 2369
1.线程 概念：多条流程执行的技术叫做多线程，例如一个购票系统可以有多个人同时购票。 1.1 多线程的实现方式一：继承Thread类 示例：
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
labview多线程学习
09-03
labview多线程学习
Java基础巩固之线程学习
01-20
一、线程的学习 　线程是程序中执行单个任务的顺序的流程。 　线程创建的两种方式： 　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { ...
线程学习.docx
03-08
线程学习
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
关于多线程学习总结
03-02
经常看到一些招聘上要求应聘者必须熟练掌握多线程，而对于我这个着实的菜鸟来说多线程这个概念虽然经常听到，但是在实际操作中用的比较少，而且了解的也比较浅显，所以乘着这休息的几天天好好的学习学习，补上这方面...
如何学习Golang语言!
FengyangCoder的博客
06-09 372
起源与设计哲学：Go语言由Robert Griesemer、Rob Pike和Ken Thompson三位Google工程师设计，旨在解决现代编程中的一些常见问题，如编译速度、运行效率和并发编程。主要特点：Go语言的语法简单、编译速度快、运行效率高，支持静态类型和内存安全，具有垃圾回收功能，并且原生支持并发编程。
扩展学习|风险管理的文献综述汇总（持续更新向）
weixin_63253486的博客
06-10 766
本片博客主要介绍风险管理领域本人所看到的一些有意思的文章，并就风险管理领域的相关内容进行一个分享。
[ue5]建模场景学习笔记（5）——必修内容可交互的地形，交互沙（3）
qq_40128113的博客
06-09 272
5.第一想法直接clear掉，但直接clear会把想要保留的痕迹一并去除，跑起来就没有痕迹！所以不行，要做一个转载，先把痕迹保留在一个载体上，清楚原来痕迹，用sandsave表示，再把这个载体的痕迹保存回原来rt，这样之前的痕迹被清空了，只留下了保存在载体上的部分，正好符合我们想要的部分。我们现在已经能够让这片地形出现在任意地方，只要角色走在这片地形上，就能够产生痕迹，但这片区域总是需要人工指定，又无法把这片区域无限扩大（显存爆炸），因此尝试使角色无论走到哪里都能产生痕迹。否则绘制不到画板上。
【电子信息工程专业课】学习记录
最新发布
共同进步！
06-12 234
- # **数字信号处理** * ## 离散时间信号与系统 + ### 周期延拓 一个连续时间信号经过理想采样后，其频谱将沿着频率轴以采样频率Ωs = 2π / T 为间隔而重复。 + ### 混频 各周期的延拓分量产生频谱交替的现象 + ### 奈奎斯特采样定理 fs > 2fh
c# 多线程学习路线
02-24
5. 学习线程池：学习如何使用线程池来管理和调度线程，以提高多线程应用程序的性能和效率。 6. 学习并发集合：学习如何使用并发集合来处理多线程环境下的数据共享和访问问题，包括并发队列、并发字典、并发栈等。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BUG忠实爱好者

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

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

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

打赏作者

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

抵扣说明：

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

余额充值