Java多线程学习2

于 2022-08-20 00:22:43 发布
阅读量174 收藏
点赞数
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ifiwerehp/article/details/126375842
版权

目录

一、线程同步

二、三大线程不安全案例

1.抢票

2.同时取一个账户的钱

3.线程不安全的集合

三、同步方法及同步块

四、死锁

五、Lock锁

六、线程协作--生产者消费者问题

1.解决方式1---管程法

2.解决方式2---信号灯法

七、线程池

前言

本文通过学习B站视频【狂神说Java】多线程详解所作

一、线程同步

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

二、三大线程不安全案例

1.抢票

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "苦逼的我").start();
        new Thread(station, "牛逼的你").start();
        new Thread(station, "可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable {

    int ticketNums = 10;
    boolean flag = true;

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

    private void buy() throws InterruptedException {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
    }
}

2.同时取一个账户的钱

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");

        Drawing you = new Drawing(account, 50, "you");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.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 drawingMoney;
    int nowMoney;

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


    @Override
    public void run() {
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }

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

        account.money = account.money-drawingMoney;
        nowMoney = nowMoney+drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        //这里的this相当于Thread.currentThread()
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}

 

3.线程不安全的集合

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

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

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

 

三、同步方法及同步块

缺点：会影响效率

同步方法：即在方法上加关键字synchronized

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "苦逼的我").start();
        new Thread(station, "牛逼的你").start();
        new Thread(station, "可恶的黄牛党").start();
    }

}

class BuyTicket implements Runnable {

    int ticketNums = 10;
    boolean flag = true;

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

    private synchronized void buy() throws InterruptedException {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
    }
}

同步块：synchronized(Obj){ }

Obj称之为同步监视器，可以是任何对象，但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为其同步监视器就是this，就是这个对象本身，或者是class（反射中讲解）

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");

        Drawing you = new Drawing(account, 50, "you");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");

        you.start();
        girlFriend.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 drawingMoney;
    int nowMoney;

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


    @Override
    public void run() {

        synchronized (account) {
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
                return;
            }

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

            account.money = account.money - drawingMoney;
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为：" + account.money);
            //这里的this相当于Thread.currentThread()
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        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());
    }
}

四、死锁

什么是死锁：多个线程互相持有对方需要的资源，形成僵持

五、Lock锁

 

public class TestLock {
    public static void main(String[] args) {
        TestLock2 lock2 = new TestLock2();
        new Thread(lock2).start();
        new Thread(lock2).start();
        new Thread(lock2).start();
    }

}

class TestLock2 implements Runnable {

    int ticketNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

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

六、线程协作--生产者消费者问题

 

1.解决方式1---管程法

 

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;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

class Consumer extends Thread {
    SynContainer container;


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

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

class Chicken {
    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 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;
    }
}

2.解决方式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) {
                this.tv.play("快乐大本营播放中");
            } else {
                this.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;
    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;

    }
}

七、线程池

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

public class TestPool {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        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());
    }
}

 

完！ 

jacknoe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程学习总结
09-14
资源包含以下内容：  Java 线程及进程  Java 中的线程类(Thread)  Java 中的 Runnable 接口  两种实现多线程方式的对比分析  Java 中线程的同步
Java-Runnable线程共享实例变量
ohcezzz的博客
12-17 2504
/** *测试Runnable线程可以共享实例变量 */public class TestRunnable implements Runnable { private int i; public void run() { i++; System.out.println(Thread.currentThread().getName()+" i="+i
JAVA 并发编程-多个线程之间共享数据（六）
热门推荐
何静媛
07-25 4万+
多线程共享数据的方式： 1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。，其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款 有两种方法来解决此类问题：将共享数据封装成另外一个对象，然后将这个对象逐一传递
volatile关键字与内存可见性
Charge8的博客
06-18 334
一、volatile关键字与内存可见性 1、测试没有 volatile关键字的demo public class VolatileTest1 { public static void main(String[] args) { ThreadDemo threadDemo = new ThreadDemo(); new Thread(threadDemo).start(); while(true){ if(threadDe
实现线程共享数据的方式
aipande143的博客
09-27 1450
说明：这里以new Thread（Runnable target）的方式创建线程。希望读者首先了解静态代理以及线程的几种创建方式。 思路：Thread类使用new Thread（Runnable target）的方式创建线程对象时，使用的是静态代理的模式，线程执行时，最终会使用target.run()方法，因此想要实现数据的共享，只要保证run方法中的数据是与其它线程共享即可，我们知道run方法是是无参的，因此只能将共享数据放在target对象中，比如作为成员变量，方便run方法调用。这样一来，保证targ
java runnable共享变量_java并发编程之：线程共享数据的方式
weixin_33187773的博客
02-28 567
java并发编程之：线程共享数据的方式多个线程对共同数据的访问的实现，要根据情况而定(1)当访问共同的代码的时候：可以使用同一个Runnable对象，这个Runnable对象中有这个共享数据，比如卖*系统就可以这么做。或者这个共享数据封装在一个对象当中，然后对这个对象加锁，也可以实现数据安全访问。(2)当各个线程访问的代码不同时：这时候要使用不同的Runnable对象，有两种实现方式：a)将共享数...
java多线程学习
11-27
主要是结合课本和视频学习了一下java多线程的用法，这个专利适合于初学者学习多线程知识。
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
JAVA多线程与并发学习总结分析
09-05
以下是对小编对JAVA多线程与并发的学习进行了总结介绍，需要的朋友可以过来参考下
多个线程之间共享数据
weixin_33721344的博客
01-12 93
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 多线程共享变量
zhengzizhi的专栏
10-09 981
范例1：启动10个线程求连续自然数累加的和，使用线程本地变量ThreadLocal<Integer> package com.contoso.demo1; public class App { public static void main(String[] args) { // 启动10个线程求连续自然数累加的和 for (int i ...
黑马程序员_日记17_Java多线程（七）
itheima_1llt的专栏
03-29 423
——- android培训、java培训、期待与您交流！ ———-线程间通信线程间的通信： 其实就是多个线程操作同一个资源，但是操作的动作不同。一、我的示例这是我写的关于线程间通信的示例。本示例需要定义三个类： 1 资源类Resource 2 输入类Input 3 输出类Output步骤： 1 先写出基本代码 2 找安全问题并修改1 初级代码//本类定义的资源是，人的数据 class R
【狂神说java多线程02】2019年5月：线程同步，买票，取款，list不安全例子。死锁，线程协作，生产者消费者，线程池，callable，FutureTask
qq120631157的博客
08-15 115
线程同步，买票，取款，list不安全例子。死锁，线程协作，生产者消费者，线程池，callable，FutureTask
多线程详解——中（线程状态、线程同步）
nswdiphone6的博客
02-04 217
3.线程状态 线程方法： setPriority(int newPriority) 更改线程的优先级。 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程体休眠。 void join()等待改线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程 （不建议使用） boolean isAlive() 测试线程是否处于活动状态 停止线程： 不推荐使用JDK提供的stop()、
Java实用教程第五版第八章_(Java大学实用教程)第八章例题例四
weixin_30737081的博客
03-02 290
class Bank implements Runnable{private int money=0;Thread zhang,cheng;Bank(){//创建的bank对象是zhang的目标对象,Bank类必须实现Runnable接口。zhang=new Thread(this);zhang.setName("会计");cheng=new Thread(this); //cheng 和zhan...
java实现数据共享_使用Runnable实现数据共享
weixin_30607173的博客
02-13 247
使用Runnable实现数据共享，供大家参考，具体内容如下先上代码：public class TestThread {private static final Logger logger = LoggerFactory.getLogger(TestThread.class);private final class MyRunnable implements Runnable {private in...
java 实例变量 共享_关于Runnable接口,多个线程共享一个target和实例变量的问题
weixin_35531726的博客
02-24 338
publicclassSecondThreadimplementsRunnable{inti;@Overridepublicvoidrun(){for(;i<20;i++){System.out.println(Thread.currentThread().getName()+"-"+i);}}publicstaticvoidmain(String[]args){...
java多线程的共享变量访问控制实例
超威半导体
09-11 6197
最近打算去一家电商公司，对于高并发的数据访问控制有着严格的要求，近期打算把多线程的知识在好好补一下。 线程调度有五个状态; 开始，可运行，运行，阻塞，死亡。 启动线程有两种方法。继承Thread类或则实现Runnable接口，其实Thread类也实现了Runnbale接口并实现了接口中唯一的方法run。但是Thread实例只能启动一次，无法共享变量，因此Runnable的灵活性更高。Threa
java多线程 学习
最新发布
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值