【JavaSE】线程，同步与死锁，Thread类 ,Runnable接口 ,synchronized ()，wait(),经典案例：生产者与消费者

已于 2022-01-24 19:47:50 修改
阅读量450 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言 后端
于 2022-01-24 16:31:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maikotom/article/details/122650851
版权

线程

一、Java中多线程的创建和使用

Thread类

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread类的特性：
      每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
      通过该Thread对象的**start()**方法来调用这个线程，启动线程

Thread类构造方法：

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象

继承Thread类创建线程

  1. 定义子类继承Thread类。
  2. 子类中重写Thread类中的run方法。
  3. 创建Thread子类对象，即创建了线程对象。
  4. 调用线程对象start方法：启动线程，调用run方法。
public class TestThread extends Thread{
    /**
     * 继承Thread的方式实现多线程
     * @author lby
     *
     */

    @Override
    public void run() {
        System.out.println("多线程运行的代码");
        for(int i = 0; i < 5; i++){

            System.out.println("这是多线程的逻辑代码:" + i);
        }
    }
}

实现Runnable接口（一般用这个）

  1. 定义子类，实现Runnable接口。
  2. 子类中重写Runnable接口中的run方法。
  3. 通过Thread类含参构造器创建线程对象。
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
  5. 调用Thread类的start方法：开启线程，调用 Runnable子类接口的run方法。
public class TestRunnable implements Runnable {
    @Override
    /**
     * 通过实现Runnable接口方式实现多线程
     * @author lby
     *
     */

    public void run() {
        int count = 0;
        //Thread.currentThread().getName()获取线程名称
            System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
            for (int i = 0; i < 5; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
            }

    }
}


public class text {
    public static void main(String[] args) {
 //       Thread t0 = new TestThread();//继承Thread类的线程
//		t0.start();//启动线程,开始运行run方法中的代码


        Thread t1 = new Thread(new TestRunnable());//传入一个Runnable的实例
        //t1.start();

        Thread t2 = new Thread(new TestRunnable() , "t-1");
        t2.start();
        Thread t3 = new Thread(new TestRunnable() , "t-2");
        t3.start();


        System.out.println("---------------");
        System.out.println("---------------");
        System.out.println("---------------");
    }
}

继承方式和实现方式的联系与区别

【区别】
继承Thread: 线程代码存放Thread子类run方法中。重写run方法
实现Runnable：线程代码存在接口的子类的run方法。实现run方法

【实现接口方式的好处】
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
一般使用实现接口方式来实现多线程

共享同一个接口实现类：

Runnable run =  new TestRunnable();
        Thread t4 = new Thread(run , "t-1");
        t4.start();
        Thread t5 = new Thread(run , "t-2");
        t5.start();

int count = 0;
    public void run() {
        //Thread.currentThread().getName()获取线程名称
            System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
            for (int i = 0; i < 5; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
            }

    }

输出结果：

t-2:Runnable多线程运行的代码
t-1:Runnable多线程运行的代码
t-1:这是Runnable多线程的逻辑代码:2
t-1:这是Runnable多线程的逻辑代码:3
t-1:这是Runnable多线程的逻辑代码:4
t-1:这是Runnable多线程的逻辑代码:5
t-1:这是Runnable多线程的逻辑代码:6
t-2:这是Runnable多线程的逻辑代码:1
t-2:这是Runnable多线程的逻辑代码:7
t-2:这是Runnable多线程的逻辑代码:8
t-2:这是Runnable多线程的逻辑代码:9
t-2:这是Runnable多线程的逻辑代码:10
共享了TestRunnable里的count

二、Thread的相关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name): 设置该线程名称
static currentThread(): 返回当前线程

线程的优先级控制
MAX_PRIORITY（10）; 最高优先级（10）
MIN _PRIORITY （1）; 最低优先级（1）
NORM_PRIORITY （5）;默认优先级（5）
涉及的方法：
getPriority() ： 返回线程优先值
setPriority(int newPriority) ： 改变线程的优先级
线程创建时继承父线程的优先级

static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()： 返回boolean，判断线程是否还活着

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

        Textrun run0 = new Textrun();
        Textrun run1 = new Textrun();

        Thread t0 = new Thread(run0);
        t0.start();
        Thread t1 = new Thread(run1);
        t1.start();

        //t0.setName("线程01");//设置名称

        //t0.setPriority(1);//设置线程的优先级
		//t1.setPriority(10);//设置线程的优先级

        //创建线程时不指定名称会输出默认名称
        // System.out.println(t0.getName());
        // System.out.println(t1.getName());

        /**
         * 线程的优先级，就是哪个线程有较大个概率被执行
         * 优先级是用数组1-10表示，数字越大优先级越高，如果没有设置默认优先级是5
         */

		// System.out.println("t0的优先级：" + t0.getPriority());//获取线程的优先级
		// System.out.println("t1的优先级：" + t1.getPriority());//获取线程的优先级

        System.out.println("---------------");
        System.out.println("---------------");
        System.out.println(t1.isAlive());//判断当前的线程是否存活

        t1.stop();//强制线程生命期结束,强制停止此线程

        try {
            t0.join();//相当于在这块把t0的run的代码插入到这个位置执行
            /**
             * 专业的说法
             * 就是阻塞当前的main方法，先不执行System.out.println("---------------3");代码
             * 先执行join进来的线程的代码
             * join的线程执行完毕之后继续执行之前main方法阻塞的代码System.out.println("---------------3");
             */
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("---------------");
        System.out.println(t1.isAlive());
    }
}


class Textrun implements Runnable{

    int count = 0;
    @Override
    public void run() {
        //Thread.currentThread().getName()获取线程名称
        System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
        for (int i = 0; i < 5; i++) {

            // if(i % 2 == 0){
			// 	Thread.yield();//线程让步
			// }

            try {
                Thread.sleep(1000);//当前线程睡眠1000毫秒
//				//相当于当前的这个循环每隔1000毫秒执行一次循环
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            count++;
            System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
        }
    }
}

三、线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

  • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
  • 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止

在这里插入图片描述

四、线程的同步Synchronized的使用方法

问题的提出
      多个线程执行的不确定性引起执行结果的不稳定
      多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

在这里插入图片描述

Java对于多线程的安全问题提供了专业的解决方式：
      同步机制

  1. ynchronized还可以放在方法声明中，表示整个方法
    为同步方法。
    例如：
          public synchronized void show (String name){
    ….
    }
  2. synchronized (对象）{
          // 需要被同步的代码；
    }

1.不加同步锁效果

public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();

        //多线程对象
        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a,2000);

        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}


class Accunt{
    public static int MONEY = 3000;//全局变量，所有的操作共享这个变量
    public void draw(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }
}

class User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
        accunt.draw(money);
    }
}
//
微信操作，余额原有金额：3000
支付宝操作，余额原有金额：3000
支付宝操作，提取金额：2000
微信操作，提取金额：2000
提款后余额为：1000
提款后余额为：-1000

2.直接在方法上加上synchronized关键字

  • 可以直接在方法上加上synchronized关键字
  • 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
  • 不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题

//可以直接在方法上加上synchronized关键字
class  Accunt{
    public static int MONEY = 3000;
    public synchronized void draw(int m){//这里加上synchronized
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }
}
//
微信操作，余额原有金额：3000
微信操作，提取金额：2000
提款后余额为：1000
支付宝操作，账户余额不足：1000

3.在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法

在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法

//在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();

        //多线程对象
        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a,2000);

        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}


class  Accunt{
    public static int MONEY = 3000;
    public synchronized void draw(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }

    public synchronized void draw1(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }
}

class  User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("微信")){
            accunt.draw1(money);
        }else
        accunt.draw(money);
    }
}
//
微信操作，余额原有金额：3000
微信操作，提取金额：2000
提款后余额为：1000
支付宝操作，账户余额不足：1000

分析：
这里微信和支付宝使用的方法是不一样的，一个是draw一个是draw1，但是也达到了同步锁的效果，因此证明了，在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法

4.不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题

//不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题

Accunt a = new Accunt();
        Accunt a1 = new Accunt();
User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a1,2000);

public void run() {
        if (Thread.currentThread().getName().equals("微信")){
            accunt.draw1(money);
        }else
        accunt.draw(money);
    }
//
微信操作，余额原有金额：3000
支付宝操作，余额原有金额：3000
支付宝操作，提取金额：2000
微信操作，提取金额：2000
提款后余额为：-1000
提款后余额为：1000

分析：
这里微信调用的是a的draw方法，支付宝调用的是a1的draw1的方法，但没有达到同步锁的效果，整明了不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题

5.静态的方法加synchronized，对于所有的对象都是使用同一个一个锁

// 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁
public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();
        Accunt a1 = new Accunt();

        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a1,2000);

        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}


class  Accunt{
    public static int MONEY = 3000;
    public static synchronized void draw2(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }
}

class  User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
        accunt.draw2(money);
    }
}
//
微信操作，余额原有金额：3000
微信操作，提取金额：2000
提款后余额为：1000
支付宝操作，账户余额不足：1000

分析：
这里的draw2是静态方法，就算创建对象的时候是分开创建的一个是a一个是a1，但是也同样可以达到同步锁效果，证明了 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁。

6.对代码块加入同步锁

public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();
        Accunt a1 = new Accunt();

        //多线程对象
        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a,2000);
        
        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}


class  Accunt{
    public static int MONEY = 3000;
    public synchronized void draw(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }

    /**
     * 对代码块加入同步锁
     * 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
     * @param m
     */
    public void draw3(int m) {
        String name = Thread.currentThread().getName();
        synchronized (this) {//表示当前的对象的代码块被加了synchronized同步锁
            if (MONEY < m) {
                System.out.println(name + "操作，账户余额不足：" + MONEY);
            } else {
                System.out.println(name + "操作，余额原有金额：" + MONEY);
                System.out.println(name + "操作，提取金额：" + m);

                MONEY = MONEY - m;
                System.out.println("提款后余额为：" + MONEY);
            }
        }
    }
}

class  User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
     
    accunt.draw3(money);
    }
}
//
微信操作，余额原有金额：3000
微信操作，提取金额：2000
提款后余额为：1000
支付宝操作，账户余额不足：1000

调用同一个对象也能达到同步锁的效果

7.synchronized (this)，this的作用

用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁，如果两次this不是同一个对象，那也锁不住。

public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();
        Accunt a1 = new Accunt();

        //多线程对象
        // User u_weixin = new User(a,2000);
        // User u_zhifubao = new User(a,2000);

        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a1,2000);

        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}

class  Accunt{
    public static int MONEY = 3000;
    public synchronized void draw(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }

   

    /**
     * 对代码块加入同步锁
     * 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
     * @param m
     */
    public void draw3(int m) {
        String name = Thread.currentThread().getName();
        synchronized (this) {//表示当前的对象的代码块被加了synchronized同步锁
            //用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
            if (MONEY < m) {
                System.out.println(name + "操作，账户余额不足：" + MONEY);
            } else {
                System.out.println(name + "操作，余额原有金额：" + MONEY);
                System.out.println(name + "操作，提取金额：" + m);

                MONEY = MONEY - m;
                System.out.println("提款后余额为：" + MONEY);
            }
        }
    }

    public void draw4(int m) {
        String name = Thread.currentThread().getName();
        synchronized (this) {//表示当前的对象的代码块被加了synchronized同步锁
            //用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
            if (MONEY < m) {
                System.out.println(name + "操作，账户余额不足：" + MONEY);
            } else {
                System.out.println(name + "操作，余额原有金额：" + MONEY);
                System.out.println(name + "操作，提取金额：" + m);

                MONEY = MONEY - m;
                System.out.println("提款后余额为：" + MONEY);
            }
        }
    }
}

class  User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
    //     if (Thread.currentThread().getName().equals("微信")){
    //         accunt.draw3(money);
    //     }else
    //     accunt.draw4(money);
     
    accunt.draw3(money);
    }
}

分析：

  1. 微信支付宝创建同一个对象，分别使用draw3和draw4，运行结果达到了同步锁的效果
  2. 微信支付宝分享创建两个对象a和a1，都使用draw3方法，但是并没有锁住
    总结：用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁，如果两次this不是同一个对象，那也锁不住

8.synchronized修饰代码块，想要根据不同的对象有不同的锁

public void drawing5(int m,Acount a){
		synchronized(a){//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
			//不同的对象就有不同的同步锁
			String name = Thread.currentThread().getName();
			
			
			if(money < m){
				System.out.println(name + "操作，账户金额不足：" + money);
			}else{
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
				money = money - m;
				System.out.println(name + "操作，取款后的余额：" + money);
			}
	}
}

9.总结

如果针对对象加同步锁就加在方法上。
如果针对某一段代码需要加同步锁，，那就直接在代码块上加同步锁

五、线程的通信

wait() 与 notify() 和 notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

wait() 方法
在当前线程中调用方法： 对象名.wait()
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权 ，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()
在当前线程中调用方法： 对象名.notify()
功能：唤醒等待该对象监控权的一个线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

public class text2 {
    public static void main(String[] args) {
        //定义用户对象
        Accunt a = new Accunt();
        Accunt a1 = new Accunt();

        //多线程对象
        User u_weixin = new User(a,2000);
        User u_zhifubao = new User(a,2000);

        Thread t0 = new Thread(u_weixin,"微信");
        Thread t1 = new Thread(u_zhifubao,"支付宝");

        t0.start();
        t1.start();
    }
}


class  Accunt{
    public static int MONEY = 3000;
    public synchronized void draw(int m){
        String name = Thread.currentThread().getName();

        if (MONEY < m){
            System.out.println(name + "操作，账户余额不足：" + MONEY);
        }else {
            System.out.println(name + "操作，余额原有金额：" + MONEY);
            System.out.println(name + "操作，提取金额：" + m);

            MONEY = MONEY - m;
            System.out.println("提款后余额为：" + MONEY);
        }
    }

    public void draw5(int m ,Accunt a) {
        String name = Thread.currentThread().getName();
        synchronized (a) {//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
			//不同的对象就有不同的同步锁

            //如果是微信操作的，先不执行，等支付宝操作，支付宝操作完，微信再继续操作
            if(name.equals("微信")){
                try {
                    this.wait();//当前的线程进入等待的阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if (MONEY < m) {
                System.out.println(name + "操作，账户余额不足：" + MONEY);
            } else {
                System.out.println(name + "操作，余额原有金额：" + MONEY);
                System.out.println(name + "操作，提取金额：" + m);

                MONEY = MONEY - m;
                System.out.println("提款后余额为：" + MONEY);
            }

            if(name.equals("支付宝")){
                try {
                    a.notify();//唤醒当前优先级最高的线程，进入就绪状态
//					a.notifyAll();//唤醒当前所有的线程，进入就绪状态
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

class  User implements Runnable{
    Accunt accunt;
    int money;

    public User(Accunt accunt,int money){
        this.accunt = accunt;
        this.money = money;
    }
    @Override
    public void run() {
 
    accunt.draw5(money , accunt);
    }
}
//
支付宝操作，余额原有金额：3000
支付宝操作，提取金额：2000
提款后余额为：1000
微信操作，账户余额不足：1000

synchronized (a) {//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
//不同的对象就有不同的同步锁
执行完支付宝在执行微信

六、经典例题：生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：
      生产者比消费者快时，消费者会漏掉一些数据没有取到。
      消费者比生产者快时，消费者会取相同的数据。

生产时不允许消费，消费时不允许生产

package day15;

/**
 * 生产者与消费者
 * @author lby
 *
 */
public class Test3 {
	public static void main(String[] args) {
		Clerk c = new Clerk();
		//消费时不生产，生产时不消费
		
		//生产者
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (c) {
					while(true){//无限循环代表无限的生产次数
						if(c.productNum == 0){//产品数为0，开始生产
							System.out.println("产品数为0，开始生产");
							while(c.productNum < 4){
								c.productNum++;//增加产品
								System.out.println("库存：" + c.productNum);
							}
							System.out.println("产品数为" + c.productNum + "，结束生产");
							
							c.notify();//唤醒消费者线程
						}else{
							try {
								c.wait();//生产者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		}, "生产者").start();
		
		//消费者
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (c) {
					while(true){//无限循环代表无限的消费次数
						if(c.productNum == 4){//产品数为4，开始消费
							System.out.println("产品数为4，开始消费");
							while(c.productNum > 0){
								c.productNum--;//消费产品
								System.out.println("库存：" + c.productNum);
							}
							System.out.println("产品数为" + c.productNum + "，结束消费");
							
							c.notify();//唤醒生产者线程
						}else{
							try {
								c.wait();//消费者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		}, "消费者").start();
		
	}
}


class Clerk{
	public static int productNum = 0;
}
晏楠先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java Thread 生产者消费者模式
qq_54302958的博客
05-30 200
java 学习笔记Thread 生产者消费者模式
java runnable wait_【Java基础_（线程篇_第一篇)】继承Thread；实现runnable;sleep、wait用法和区别；Thread和Runnable区别；线程停止...
weixin_42133680的博客
02-16 545
一、线程两种实现1.继承Thread类：(1)【直接在主类继承】package org;// 继承 Thread 类public class TestThreadofExt extends Thread{private static int count = 0;public static void main(String[]args){// new 一个 线程，然后启动TestThreadofEx...
java线程调用wait方法_什么时候可以在Java中调用线程的wait()和wait(long)方法？
weixin_36006790的博客
02-28 1816
每当在对象上调用wait()方法时，它都会导致当前线程等待，直到另一个线程为此对象调用notify()或notifyAll()方法，而wait(long timeout)导致当前线程等待直到另一个线程线程为此对象调用notify()或notifyAll()方法，或者指定的超时时间已经过去。等待()在下面的程序中，当在对象上调用wait()时，线程从运行状态进入等待状态。它等待其他线程调用notif...
【java高级程序设计】线程||多线程||Runnable||Thread||多线程实现消费者生产者
weixin_51159944的博客
11-05 209
Basic 继承Thread类 public class MyThread extends Thread{ private String title; public MyThread(String title){ this.title=title; } @Override public void run(){ for(int i=0; i<10; i++){ System.out.println(..
生产者消费者问题--使用实现Runnable的方式解决
qq_47711757的博客
04-16 1512
多线程经典题：生产者消费者问题。
继承Runnable 实现Synchronized 同步锁
weixin_34008784的博客
11-30 180
在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。 java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就...
javaSE多线程的案例源代码
04-01
实现Runnable接口允许代码与特定的类结构保持松散耦合，而继承Thread类则可以直接重写run()方法，让类本身成为线程实体。 线程的`优先级`决定了哪个线程应该先执行。Java定义了三个主要的优先级：MIN_PRIORITY...
JavaSE专题-多线程总结.doc
06-03
我们可以创建`Thread`类的子类，或者实现`Runnable`接口来创建和控制线程。 3. **创建线程的方式** - **继承Thread类**： - 定义一个类继承`Thread`，重写`run`方法。 - 创建子类对象，调用`start`方法启动线程...
javaSE 死锁,多线程同步嵌套
houyanhua1的专栏
06-19 276
运行Java： java -Xms100M -Xmx200M HelloWorld;  运行java程序时,手动分配内存的最大值和最小值,可以优化垃圾回收。 故障诊断：死锁(安装ThreadDump,可以定位产生死锁的位置信息)   Demo.java： package cn.xxx.demo; public class Demo { public static void main(S...
JavaSE_线程_电子书_源代码_PPT
04-01
1. **线程创建**：在Java中，我们可以通过两种方式创建线程：继承`Thread`类或实现`Runnable`接口。继承`Thread`类直接创建一个线程类，重写`run()`方法，然后创建该类的实例并调用`start()`方法启动线程。而实现`...
synchronized 实现多线程 implements Runnable
11-21
一个简单的多线程代码示例，Java实现，用于实现同一时刻，只允许一个线程调用执行的代码块或类，即synchronized的如何使用（多线程实现），实现 Runnable
JavaSE之多线程实战视频课程
06-09
线程同步是解决多线程并发问题的关键，Java提供了多种同步机制，如`synchronized`关键字、`wait()`、`notify()`和`notifyAll()`方法、`Lock`接口（包括`ReentrantLock`）以及`Semaphore`等。这些工具用于控制对共享...
对线程的基本理解（3）
weixin_51369307的博客
08-24 159
java中有三种停止线程方法： 1)使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法方法强行终止线程，但是不推荐使用这个方法，应为stop不安全而且已经被废弃的方法，还有suspend和resume都是废弃的方法。 3）使用interrupt方法中断线程。 interrupt()方法 仅仅使线程中打了一个停止的标记，并不是真的停止线程。 this.interrupted() 测试当前线程是否已经中断。 this.isInterrupted()测试线程是否已经
Java多线程：同步的案例
hefrankeleyn的博客
10-14 258
本文记录Java多线程同步的案例。 背景：银行（Bank）里面有多个账户，将两个账户进行转账（调用Bank对象的transfer方法），这在个过程中，银行里钱的总额保持不变。 客户端：开启多个线程进行转账操作 import java.util.Random; /** * UnsynchBankTest */ public class UnsynchBankTest { pu...
Runnable，Thread.run，wait，notify
simon_it的博客
09-19 703
线程同时存在Runable和Thread的run方法先执行哪一个？先看源码 /** * If this thread was constructed using a separate * &lt;code&gt;Runnable&lt;/code&gt; run object, then that * &lt;code&gt;Runnable&lt;/co...
Runnable接口 和 同步代码块synchronized
panyu_SMD的博客
04-01 478
[java] view plaincopy /*      需求： 实现一个售票程序            创建线程的第二种方式：实现Runnable接口        步骤：      1，定义类实现Runnable接口      2，覆盖Runnable接口中的run方法          将线程要运行的代码存放在该run方法中
Java初学习 - Runnable接口 和 同步代码块synchronized
myKernel
01-04 3099
[java] view plaincopy /*      需求： 实现一个售票程序            创建线程的第二种方式：实现Runnable接口        步骤：      1，定义类实现Runnable接口      2，覆盖Runnable接口中的run方法          将线程要运行的代码存放在该run方法中        
Java基础十八、十九和二十天合：多线程Thread+Runnable+同步锁+设计模式+注解+反射+socket/网络编程/内部类
chenxi26的博客
11-25 171
多线程 1.概述 为了提高程序的运行效率 2.进程和线程 进程：是指正在运行的程序 线程：是指进程的实际运行单位，也是直接被操作系统调度 一个软件的运行依赖一个或者多个进程，一个进程包含一个或者多个线程 3.并行和并发 并行：是多个CPU，对应多个程序，每个CPU执行一个程序，不用抢 并发：是多个程序抢占CPU的执行权 效率：并发 > 并行 4.模拟多线程编程方式 继承Thread：好处是可以使用父类的所有功能，坏处是单继承/强耦合 实现Runnable接口：好处是解耦合，可以多继承多实现 Threa
java runnable wait_面试官:都说阻塞 I/O 模型将会使线程休眠，为什么 Java 线程状态却是 RUNNABLE？...
weixin_28928727的博客
02-16 338
摘要: 原创出处 https://studyidea.cn 「公众号：程序通事 」欢迎关注和转载，保留摘要，谢谢！使用 Java 阻塞 I/O 模型读取数据，将会导致线程阻塞，线程将会进入休眠，从而让出 CPU 的执行权，直到数据读取完成。这个期间如果使用 jstack 查看线程状态，却可以发现Java 线程状态是处于 RUNNABLE，这就和上面说的存在矛盾，为什么会这样？上面的矛盾其实是混淆了...
Java Runnable接口下的多线程启动与Thread类详解
在Java程序设计中，实现Runnable接口而非直接继承Thread类来创建多线程是一种常见的实践。这种方式使得代码更加灵活，因为一个类可以同时被多个线程实例化并执行。然而，尽管Runnable接口不提供start()方法，但可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值