多线程基础知识补充

最新推荐文章于 2024-04-23 18:35:40 发布
最新推荐文章于 2024-04-23 18:35:40 发布
阅读量68 收藏
点赞数
分类专栏： 笔记 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46976922/article/details/115032874
版权

多线程

  1. 同步

    • 多个线程操作同一个资源 并发

    • 对象等待池 队列

    • 锁

      • 降低性能

      • 性能倒置

      • 线程挂起

      • 死锁

        • 相互等待对方资源
        • 产生条件
          • 一个资源只能被一个进程使用
          • 请求和保持条件
          • 不剥夺条件
          • 循环等待条件
        //测试死锁
public class DeadLock {
    public static void main(String[] args){
        new Make(0,"小红").start();
        new Make(1,"小明").start();
    }
}

//口红
class Lipstick {}

//镜子
class Mirror {}

class Makeup extends Thread {
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    
    int choice;
    String girlName;
    public Makeup(String name,choice){
        this.girlName = name;
        this.choice = choice;
    }
    
    public void run(){
        if(choice==0){
            synchronized (lipstick){
                System.out.println(this.girlName()+"获得口红");
                Thread.sleep(1000);
                //死锁
                synchronized(mirror){
                    System.out.println(this.girlName()+"获得镜子");
                }
            }
        }
        if(choice==1){
            synchronized (mirror){
                System.out.println(this.girlName()+"获得镜子");
                Thread.sleep(1000);
                synchronized(lipstick){
                    System.out.println(this.girlName()+"获得口红");
                }
            }
        }
    }
}

    • 队列 + 锁 = 线程同步(synchronized)

      //不安全的门票
public class UnsafeBuyTicket {
    public static void main(String[] args){
        BuyTicket buy = new BuyTicket();
        
        new Thread(buy,"可恶的黄牛党1").start();
        new Thread(buy,"可恶的黄牛党2").start();
        new Thread(buy,"学生").start();
    }
}

class BuyTicket implements Runnable {
    //票数
    private int ticketNums = 10;
    private boolean flag = true;
    
    //买票
    public void run(){
        while(flag){
            try{
                Thread.sleep(1000);
            }catch(InterruptedException i){
                i.printStackTrace();
            }
            buy();
            System.out.println(Thread.currentThread().getName()+"抢到了第"+ticketNums--+"张票");
        }
    }
    
    //判断是否有票
    private synchronized void buy() throws InterruptedException{
        if(ticket<=0){
            flag = false;
            //return;
        }
    }
}

      银行取钱

      //
public class UnSafeBank {
    public static void main(String[] args){
        Account account = new Account(1000,"湖州宁");
        
        WithDraw drawMoney = new WithDraw("HU",1000,account);
        WithDraw drawMoney1 = new WithDraw("ZO",1000,account);
        
        drawMoney.start();
        drawMoney1.start();
    }
}

//账户
class Account {
    double money;
    String name;
    
    public Accout(double money,String name){
        this.money = money;
        this.name = name;
    }
}

//取钱操作类
class WithDraw extends Thread {
    private final Account account;
    private final double drawingMoney;
    //private double nowMoney;
    
    public WithDraw(String name,double drawingMoney,Account account){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    
    public void run(){
       synchronized(account){
           if(isMoney){
           try{
               Thread.sleep(1000);
           }catch(InterruptedException i){
               i.printStackTrace();
           }
           
           this.account.money = this.account.money - this.drawingMoney;
           
           System.out.println(this.getName()+"取钱成功,取钱"+this.drawingMoney);
           System.out.println(this.account.name+"账户余额为:"+this.account.money);
       	  }
       }
    }
    
    //判断余额是否充足
    public boolean isMOney(){
        if(this.account.money==0&&this.account.money<this.drawingMoney){
            System.out.println("取钱失败，余额不足!");
            return false;
        }
        else{
            return true;
        }
    }
}

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

//线程不安全的集合
public class UnSafeList {
    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();
        }
        System.out.println(list.size());
    }
}

      import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC并发 JUC线程安全类
public class TestJUC {
    public static void main(String[] args){
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for(int i = 0; i < 1000; i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName())
            }).start();
        }
    }
}

      • Lock 锁

        import java.util.concurrent.ReentrantLock;
//Lock加锁测试
public class TestLock{
    public static void main(String[] args){
        TicketLock ticketLock = new TicketLock();
        
        new Thread(ticketLock,"a").start();
        new Thread(ticketLock,"b").start();
        new Thread(ticketLock,"c").start();
    }
}

class TicketLock implements Runnable{
    private int ticketNums = 10;
    //定义锁
    private final ReentrantLock lock = new ReentrantLock();
    
    public void run(){
        while(true){
            try{
                lock.lock();//加锁
            	try{
                	Thread,sleep(1000);
            	}catch(InterruptedException i){
                	i.printStackTrace();
            	}
            	if(ticketNums<=0){
                	break;
            	}else{
                	System.out.println(ticketNums--);
            	}
            }finally{
                lock.unlock();//解锁
            }
        }
    }
}

        //测试生产消费者问题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 {
    private Tv tv;
    public Player(Tv tv){
        this.tv = tv;
    }
    public void run(){
        for(int i = 0; i < 20; i++){
            if(i<10){
                this.tv.play("喜羊羊与灰太狼");
            }else{
                this.tv.play("猫和老鼠");
            }
        }
    }
}
//观众
class Watcher extends Thread {
    private Tv tv;
    public Watcher(Tv tv){
        this.tv = tv;
    }
    
    public void run(){
        for(int i = 0; i < 20; i++){
            this.tv.watch();
        }
    }
}

class Tv {
    String voice;//节目
    boolean flag = true;//标志位
  
    public synchronized void play(String voice){
        if(!flag){
            try{
                this.wait();//等待
            }catch(InterruptedException i){
                i.printStackTrace();
            }
        }
        System.out.println("演员表演了:"+this,voice);
        this.flag = !this.flag;
        this.voice = voice;
        //通知观看
        this.notify();
    }
    
    public synchronized void watch(){
        if(flag){
            try{
                this.wait();//等待
            }catch(InterruptedException i){
                i.printStackTrace();
            }
        }
        System.out.println("观众观看了"+this.voice);
        this.flag = !this.flag;
        //通知表演
        this.notify();
    }
}

  2. 通信问题

    • 线程协作

    • 生产者消费者模式

    • wait()等待

    • notify()唤醒

    • 管程法

      //测试:
public class TestPc {
    public static void main(String[] args){
        SynContainer container = new SynContainer();
        
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread {
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
    public void run(){
        for(int i = 0; i < 1000; i++){
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread {
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }
    public void run(){
        for(int i = 0; i < 1000; i++){
            container.pop();
            System.out.println("消费了"+i+"只鸡");
        }
    }
}
//产品
class Chicken {
    private int id;
    public Chicken(int id){
        this.id = id;
    }
}
//缓存区
class SynContainer {
    Chicken[] chickens = new Chicken[10];
    int count = 0;
    
    public synchronized void push(Chicken chicken){
        if(count==chickens.length){
            //产品已满 通知消费者消费
            try{
                this.wait();//通知
            }catch(InterruptedException i){
                i.printStackTrace();
            }
        }
        
        chikens[count] = chicken;
        count++;
        //产品不够 唤醒生产
        this.notify();
    }
    
    public synchronized void pop(){
        if(count==0){
            //产品消费完 通知生产
            try{
                this.wait();
            }catch(InterruptedException i){
                i.printStackTrace();
}
        }
        
        count--;
        Chicken chicken = chickens[count];
        return chicken;
        //唤醒消费
        this.notify();
    }
}

  3. 高级主体

    import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors
//测试线程池
public class TestPool {
    
    public static void main(String[] args){
        //1.创建服务，创建线程城池
        //newFixedThreadPool 差数为:线程池大小
        ExecutorService service = Executors.newFixedThreadPool(3);
        //执行
        service.execute(new ThreadPool());
        service.execute(new ThreadPool());
        service.execute(new ThreadPool());
        //关闭
        service.shutDown();
    }
}

class ThreadPool implements Runnable {
    public void run(){
        for(int i = 0; i < 3; i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

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

//测试Callable 
public class TestCall{
    public static void main(String[] args){
        FutureTask<Integer> task = new FutureTask<Integer>(new MyThread());
        new Thread(task).start();
        
        try{
            System.out.println(task.get());
        }catch(InterruptedException i){
            i.printStackTrace();
        }catch(ExecutionException e){
            e.printStackTrace();
        }
    }
}

class MyThread implement Callable<Integer> {
    public Integer call(){
        System.out.println("Callable");
        return 100;
    }
}
qq_46976922
关注
专栏目录
Java多线程基础知识总结
weixin_43860783的博客
11-07 2275
<-----------------------------------------廖雪峰学Java-----------------------------------------> 目录1. 多线程基础知识2. 创建多线程3. 线程状态4. 中断线程5. 守护线程6. 线程同步7. 同步方法8. 死锁9. 使用wait和notify10. 使用ReentrantLock11. 使用Condition12. 使用ReadWriteLock13. 使用StampedLock14. 使用Concu
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2035
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
Java 多线程基础知识整理
Evie的博客
03-22 1362
文章目录多线程概念为什么要用多线程？多线程难点线程生命周期线程调度上下文切换线程创建线程启动线程常用方法用户线程和守护线程补充：定时器机制线程安全概念三性同步与异步编程模型同步机制锁的概念内部锁 synchronizedvolatilesynchronized VS volatileLock（锁）synchronized VS Lock锁的类型可重入锁可中断锁公平锁死锁线程通信生产者消费者模型线程池概述优点线程池的状态处理流程线程池相关 APIExecutorExecutor 两层调度模型Executor
【多线程】多线程基础知识
吞吞吐吐大魔王的博客
08-15 1222
Runnable 接口时线程辅助类，仅定义了一个 fun() 方法。该方法中描述了要实现的线程的内容。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6304
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
线程基础知识
qwertf123的博客
04-23 1107
线程基础知识
一文帮你深度剖析多线程相关知识(基础篇上)
Biteht的博客
03-25 2502
一文帮你深度学习Thread类的基本用法,以及线程的创建中断等待休眠等问题(基础篇上建议收藏)
【嵌入式Linux】嵌入式Linux应用开发基础知识之多线程编程
永远年轻 永远热泪盈眶
02-24 2299
韦东山嵌入式Linux应用开发基础知识学习笔记 嵌入式Linux应用开发基础知识之多线程编程
java基础之多线程与Lambda表达式
热爱编写程序的药学在读书
04-23 1632
一、Lambda表达式 Java从1.8以后引入了函数式编程，这是很大的一个改进。函数式编程的优点在提高编码的效率，增强代码的可读性。本文历时两个多月一点点写出来，即作为心得，亦作为交流。 1、无参和返回值 这样写非常的简单，其实就是简化我们的代码量，可以提供性能。 2、有且只能定义一个方法 3、有参实现 4、函数式接口 以上的接口必须是一个，java8出现了一个新的注解 只能写一个方法 6、default关键字的复习 二、java多线程 1、进程与线程 （1）进程概念 （2）线
多线程
BruceShi的博客
02-01 1489
java中的多线程是一个同时执行多个线程的进程，线程是一个轻量级的子进程，是最小的处理单位。线程是进程的一条执行路径， 而进程是线程的集合。 1.优点：          ① 他不会阻塞用户，因为线程是独立的，可以同时执行多个操作。          ② 可以一起执行许多操作，因此可以节省时间。（提高程序效率）          ③ 线程是独立的，因此如果单个线程中发生异常，他不会影响其...
Android实现网络多线程文件下载
01-20
总之，Android实现网络多线程文件下载涉及网络请求、多线程编程、数据同步、UI更新以及错误处理等多个方面，需要开发者具备扎实的Android基础和良好的编程实践。通过合理的多线程设计和优化，可以提供更高效、稳定且...
java多线程案例——未完成
08-21
下面是对Java多线程基础知识的详细解释： 1. **线程的创建方式**： - 继承`Thread`类：自定义一个新的类，继承Java的`Thread`类，并重写`run()`方法。创建实例后调用`start()`方法启动线程。 - 实现`Runnable`...
Java高级特性 - 多线程基础（3）线程同步
m0_56638814的博客
07-06 312
Java高级特性 - 多线程基础（3）线程同步
Java高级特性 - 多线程基础（1）使用线程
m0_56638814的博客
07-06 1268
Java高级特性 - 多线程基础（1）使用线程
多线程与高并发编程基础知识
小白码农的博客
01-16 254
基础概念 进程、线程、纤程 进程相对于程序来说是一个动态的概念，如：QQ、微信等是一个程序，当双击程序时，程序运行起来就是一个进程。作为进程中一个最小的执行单元，就是线程， JUC同步工具 同步容器 线程池 Disruptor框架-单机环境下效率、性能最高 ...
基于asp.net的房地产管理系统设计与实现.docx
09-29
基于asp.net的房地产管理系统设计与实现.docx
基于asp.net的小型企业办公耗材库存管理系统设计与实现.docx
09-29
基于asp.net的小型企业办公耗材库存管理系统设计与实现.docx
基于Vue和Element的电脑配件管理系统设计源码
最新发布
09-29
该项目为基于Vue和Element UI框架构建的电脑配件管理系统源码，包含89个文件，涉及32个JavaScript文件、20个Vue组件文件、12个SVG图标文件、6个SCSS样式文件、3个PNG图片文件、2个YAML配置文件、2个Markdown文件、2个JPG图片文件、1个EditorConfig配置文件以及1个开发相关文件。该系统主要使用JavaScript和Vue进行开发，辅以HTML和SVG技术，旨在提供一套高效便捷的电脑配件管理解决方案。
非标自动化设备【B81】.zip
09-29
非标自动化设备【B81】.zip
Linux多线程编程实战与参考
该手册旨在帮助读者理解和掌握多线程编程的基础知识与实践技巧，适用于那些在开发过程中可能遇到问题或需要回顾概念的工程师。它涵盖了多线程编程的核心原理，包括如何在Linux环境中创建、管理和同步线程，以及如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值