Java多线程编程(同步、死锁、生产消费)

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量202 收藏
点赞数 2
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java_Pluto/article/details/116012552
版权

线程同步 死锁 生产者消费者模型 Java synchronized
关键词由CSDN通过智能技术生成

关于线程同步以及死锁问题：

线程同步概念：是指若干个线程对象并行进行资源的访问时实现的资源处理保护操作；

线程死锁概念：是指两个线程都在等待对方先完成，造成程序的停止的状态；

先了解相应的概念，后面深入理解。

同步：
举个例子：还是卖票问题（经典❗）

  1. 不存在同步
  2. 开启三个线程(售票员)测试
package com.xbhog;
class MyThread implements Runnable {// 定义线程执行类
    private int ticket = 3;// 总票数为6张
    @Override
    public void run() {
        while (true) {	// 持续卖票
            if (this.ticket > 0) {	// 还有剩余票
                try {
                    Thread.sleep(100);	// 模拟网络延迟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //获取当前线程的名字
                System.out.println(Thread.currentThread().getName() +
                        "卖票，ticket = " + this.ticket--);
            } else {
                System.out.println("***** 票已经卖光了 *****");
                break;// 跳出循环
            }
        }
    }
}
public class Java多线程核心 {
    public static void main(String[] args) throws Exception {
        MyThread mt = new MyThread();
        new Thread(mt, "售票员A").start();	// 开启卖票线程
        new Thread(mt, "售票员B").start();	// 开启卖票线程
        new Thread(mt, "售票员C").start();	// 开启卖票线程
    }
}

结果：
在这里插入图片描述
存在上述原因是因为在代码中两个地方存在多线程访问时出现模糊的问题:

  1. this.ticket>0;
  2. this,ticket–;

假设现在剩余的票数为1张；当第一个线程满足售票的条件的时候（此时还未减少票数），其他的线程也可能同时满足售票的条件，这样同时进行自减减就可能造成负数！

解决上述问题就需要采用线程同步技术实现；

首先需要明确，在Java中实现线程同步(synchronized)的方法有两个：

1.同步代码块(同步策略加在方法内部)

package com.xbhog.多线程1;
class MyThread implements Runnable {						// 定义线程执行类
    private int ticket = 3; 								// 总票数为6张
    @Override
    public void run() {
        while (true) {									// 持续卖票
            synchronized(this) {							// 同步代码块
                if (this.ticket > 0) {					// 还有剩余票
                    try {
                        Thread.sleep(100);				// 模拟网络延迟
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +
                            "卖票，ticket = " + this.ticket--);
                } else {
                    System.out.println("***** 票已经卖光了 *****");
                    break;								// 跳出循环
                }
            }
        }
    }
}
public class Java多线程同步代码块 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt, "售票员A").start();					// 开启卖票线程
        new Thread(mt, "售票员B").start();					// 开启卖票线程
        new Thread(mt, "售票员C").start();					// 开启卖票线程
    }
}

售票员A卖票，ticket = 3
售票员C卖票，ticket = 2
售票员B卖票，ticket = 1
***** 票已经卖光了 *****
***** 票已经卖光了 *****
***** 票已经卖光了 *****

2.同步方法(同步策略加在方法上)

class MyThread implements Runnable {						// 定义线程执行类
	private int ticket = 3; 								// 总票数为6张
	@Override
	public void run() {
		while (this.sale()) {								// 调用同步方法
			;
		}
	}
	public synchronized boolean sale() {					// 售票操作
		if (this.ticket > 0) {
			try {
				Thread.sleep(100); 						// 模拟网络延迟
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + 
				"卖票，ticket = " + this.ticket--);
			return true;
		} else {
			System.out.println("***** 票已经卖光了 *****");
			return false;
		}
	}
}
public class ThreadDemo {
	public static void main(String[] args) throws Exception {
		MyThread mt = new MyThread();
		new Thread(mt, "售票员A").start();					// 开启卖票线程
		new Thread(mt, "售票员B").start();					// 开启卖票线程
		new Thread(mt, "售票员C").start();					// 开启卖票线程
	}
}

售票员A卖票，ticket = 3
售票员C卖票，ticket = 2
售票员B卖票，ticket = 1
***** 票已经卖光了 *****
***** 票已经卖光了 *****
***** 票已经卖光了 *****

同步的本质：在同一个时间段只允许有一个线程执行资源，所以在此线程对象未执行完的过程中其他线程对象将处于等待的状态。

同步的优点与缺点：

  1. 可以保证数据的准确性

  2. 数据线程的访问安全

  3. 程序的处理性能下降

死锁：

实例：

假如现在又张三想要李四的画，李四想要张三的书，那么张三对李四说：把你的画给我，我就给你书；

李四对张三说：把你的书给我，我就给你画；

此时：张三在等待李四，李四在等待张三，两人一直等待下去形成死锁；

观察线程的死锁：(实现张三李四)

package com.xbhog.死锁;

class Book {
    public synchronized void tell(Painting paint) {		// 同步方法
        System.out.println("张三对李四说：把你的画给我，我就给你书，不给画不给书！");
        paint.get();
    }
    public synchronized void get() {						// 同步方法
        System.out.println("张三得到了李四的画开始认真欣赏。");
    }
}
class Painting {
    public synchronized void tell(Book book) {				// 同步方法
        System.out.println("李四对张三说：把你的书给我，我就给你画，不给书不给画！");
        book.get();
    }
    public synchronized void get() {						// 同步方法
        System.out.println("李四得到了张三的书开始认真阅读。");
    }
}
public class DeadLock implements Runnable{
    private Book book = new Book();
    private Painting paint = new Painting();
    public DeadLock() {
        new Thread(this).start();
        book.tell(paint);
    }
    @Override
    public void run() {
        paint.tell(book);
    }
    public static void main(String[] args) {
        new DeadLock() ;
    }
}

由于现在电脑的配置问题，该代码有可能在一次运行中展示不出效果来，需要多次运行观察效果；

效果图：
在这里插入图片描述
由此引申出了生产者与消费者模型。

生产者与消费者问题：

首先需要明确生产者与消费者为两个线程对象，是对同一资源进行数据的保存与读取；

基本操作是：生产者生产一个资源，消费者则取走一个资源，一一对应。

对应类关系图：
在这里插入图片描述
我们需要设想一个问题，如果不加任何操作的话，会出现什么问题？

  1. 数据错位：当生产者线程只是开辟了一个栈空间保存信息名称，在想存数据但是还没存数据的时候切换到了消费者线程上，那么消费者线程将会把这个信息名称与上个信息的内容进行结合联系，这样就造成了数据的错位。
  2. 重复数据：当生产者放了若干次的数据，消费者才开始取数据，或者消费者取完，但生产者还没生产新数据时又取了直接已经取过得数据。

解决以上两个问题需要涉及到以下两个知识点：

设置同步代码块或设置同步方法>>>解决数据错误问题

Object线程等待与唤醒>>>解决数据重复设置以及重复取出的问题

增加数据同步方法或同步代码块：

在本程序中，生产者与消费者代表的都是线程对象，所以同步操作只能在Message类中，可以将set与get方法设置为单独的同步方法。

class Message {
	private String title ;							// 保存信息的标题
	private String content ;							// 保存信息的内容
	public synchronized void set(String title, String content) {
		this.title = title;
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.content = content;
	}
	public synchronized String get() {
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return this.title + " --> " + this.content;
	}
	// setter、getter略
}
class Producer implements Runnable {					// 定义生产者
	private Message msg = null ;
	public Producer(Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 50; x++) {				// 生产50次数据
			if (x % 2 == 0) {
				this.msg.set("xbhog","22") ;	// 设置属性
			} else {
				this.msg.set("xbhog","www.cnblog.cn/xbhog") ;	// 设置属性
			}
		}
	}
}
class Consumer implements Runnable {					// 定义消费者
	private Message msg = null ;
	public Consumer (Message msg) {
		this.msg = msg ;
	}
	@Override
	public void run() {
		for (int x = 0; x < 50; x++) {				// 取走50次数据
			System.out.println(this.msg.get()); 		// 取得属性
		}
	}
}
public class ThreadDemo {
	public static void main(String[] args) throws Exception {
		Message msg = new Message() ;					// 定义Message对象，用于保存和取出数据
		new Thread(new Producer(msg)).start() ;		// 启动生产者线程
		new Thread(new Consumer(msg)).start() ;		// 取得消费者线程
	}
}

Object线程等待与唤醒机制：

线程的等待与唤醒只能依靠Object来完成，如果想要让生产者与消费者一个一个拿，一个一个取，那么需要加入标志位来确定线程的当前状态；

由图所示：
在这里插入图片描述
当生产者线程与消费者线程进入时，判断当前的标志位是否为true,

true:表示生产者可以生产资源，但是消费者不能取走资源

false:表示生产者不能生产资源，但是消费者需要取走资源

class Message {
	private String title ;
	private String content ;
	private boolean flag = true; 					// 表示生产或消费的形式
	// flag = true：允许生产，但是不允许消费
	// flag = false：允许消费，不允许生产
	public synchronized void set(String title,String content) {
		if (this.flag == false) {						// 无法进行生产，等待被消费
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} 
		}
		this.title = title ;
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.content = content ;
		this.flag = false ; 							// 已经生产过了
		super.notify(); 								// 唤醒等待的线程
	}
	public synchronized String get() {
		if (this.flag == true) {						// 还未生产，需要等待
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			return this.title + "  -  " + this.content ;
		} finally {										// 不管如何都要执行
			this.flag = true ; 							// 继续生产
			super.notify(); 								// 唤醒等待线程
		}
	}
}

在本程序中追加一个数据产生与消费的控制逻辑成员属性，通过此程序的值控制实现线程的等待与唤醒处理操作，从而解决线程重复操作的问题。

Java_Pluto
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Java多线程编程（一）：创建并运行Java线程
journey_fan的专栏
05-18 823
Java线程类也是一个Object类，它的实例都继承自java.lang.Thread或其子类。可以用如下方式在Java中创建一个线程： Thread thread = new Thread(); 执行该线程可以调用该线程的start()方法: thread.start(); 在上面的例子中，我们并没有为线程编写运行代码，因此调用该方法后线程就终止了。 编写线程运行时执行的代码有两
Java多线程并发编程
weixin_42408579的博客
10-23 126
Java并发编程总结 实现线程是并发编程中基础中的基础 一 线程的使用 有四种使用线程的方法： 实现 Runnable 接口； 实现 Callable 接口； 继承 Thread 类。 线程池 实现 Runnable 接口 public class MyRunnable implements Runnable { @Override public void run() { System.out.println('用实现Runnable接口实现线程'); } }
java（模拟王老师、李老师和张老师三个老师同时分发80份学习笔记，每个老师相当于一个线程。）
爱学习的JackYang的博客
11-30 6869
public class Note { public static void main(String[] args){ Paper quantity=new Paper(); new Thread(quantity,"王老师").start(); new Thread(quantity,"李老师").start(); new Thread(quantity,"张老师").sta...
【程序练习题】Java多线程
小源同学的博客
11-10 800
模拟三个老师同时分发80份学习笔记，每个老师相当于一个线程 /** * @Author 小源同学 * @Date 2021 11 10 21 40 * @Describe Please describe the role of this class **/ public class Thread_subnotes { public static void main(String[] args) { TeacherToNotes t = new TeacherToNotes()
关于Java多线程---------（3，同步与死锁）
jakezhang1990的专栏
06-24 397
1，线程同步的作用2，同步代码块以及同步方法的作用3，死锁的产生在多线程的开发中，同步与死锁是非常重要的，那么问题来了，对于这两个东西，需要思考几个问题。1，代码的什么地方需要同步；2，如何实现同步；3，实现同步之后有哪些副作用。1，问题的出现，为什么要有同步？（什么是同步，为什么要有同步）举个例子来说，卖火车票，售卖火车票会有多个售票站点，一趟火车的座位数是固定的，把各个售票点就可以理解为各个线程
线程同步（互斥量、死锁、读写锁、生产者与消费者模型实现）
编程小镇
02-04 367
线程同步（互斥量、死锁、读写锁、生产者与消费者模型实现）线程同步互斥量 mutexmutex 相关系统调用死锁读写锁条件变量实现生产者与消费者模型信号量实现生产者与消费者模型 线程同步   在多线程进行   线程的主要优势在于，能够通过全局变量来共享信息。不过，这种便捷的共享是有代价的：必须确保多个线程不会同时修改同一变量，或者某一线程不会读取正在由其他线程修改的变量。   临界区是指访问某一共享资源的代码片段，并且这段代码的执行应为原子操作，也就是同时访问同一共享资源的其他线程不应终端该片段的执行。   
采用信号量机制实现消费者与生产者的线程同步_信号量机制
weixin_39706561的博客
12-11 626
什么是信号量信号量是一种变量或抽象数据类型，用于控制并发系统中多个进程对公共资源的访问一个普通的信号量是一个普通的变量，可以对它进行递增或递减，或切换等操作。引用一波百度百科的解释：以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一...
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
java多线程编程之使用Synchronized块同步方法
09-04
Java多线程编程中，`synchronized`关键字是实现线程同步的关键，它可以防止多个线程同时访问共享资源，从而避免数据不一致的问题。在Java中，`synchronized`有两种使用方式：同步方法和同步代码块。 1. 同步方法： ...
Java多线程编程的优点和缺点
10-16
Java多线程编程是开发高效率、高性能应用的关键技术之一，尤其在当今多核处理器普及的时代。通过创建多个线程，程序能够同时处理多个任务，从而显著提高响应速度和资源利用率。然而，多线程也带来了一系列挑战和潜在...
JAVA多线程编程技术PDF
08-28
总结起来，“JAVA多线程编程技术PDF”涵盖了多线程的基本概念、同步机制、线程通信、死锁避免、线程池以及线程安全的集合类等内容。通过深入学习这份资料，开发者可以全面掌握Java多线程编程技术，提升程序的并发...
Java多线程编程实战之模拟大量数据同步
08-26
Java多线程编程实战之模拟大量数据同步是一个关键的话题，特别是在大数据处理和高并发系统中。这个主题涉及到了如何在Java环境中有效地管理和同步大量数据，确保数据一致性与系统的稳定性。 首先，我们要理解Java多...
线程同步消费事件-spring
jiaysoft的博客
12-04 402
1.单线程消费事件 新建事件监听类(交给spring来管理-@Component 注入) 2.事件处理总类 NmaeEventController(名称可自定义)实现ApplicationListener 接口 @Component类注入NmaeEventController交spring管理,此类用于注册在java启服时候依赖spring的类.register(
java多线程同步问题--生产者与消费者
LittleSunlight的博客
10-22 665
线程的同步问题 当我们使用多线程对同一块数据进行操作的时候，会出现线程的同步，导致数据的错误，所以我们要对多线程的公共数据块上锁。 同步机制synchronized：synchronized关键字用于修饰方法或者单独的synchronized代码块，当一个线程想执行synchronized中的内容时，必须先获取到对象锁，当对象锁没有线程占用时，进入synchronized方法会自动获取到对象锁，执...
线程同步生产者消费者模式 JAVA
qq_42983641的博客
06-17 128
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
【java 多线程】多线程并发同步问题及解决方法
weixin_30699831的博客
11-18 1656
一、线程并发同步概念 线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合，“同步”就是协同步调昨，也就是按照预定的先后顺序进行运行，即“你先，我等， 你做完，我再做”。 线程同步，就是当线程发出一个功能调用时，在没有得到结果之前，该调用就不会返回，其他线程也不能调用该方法。 就一般而言，我们在说同步、异步的时候，特指那些需要其他组件来配合或者需要一定时间来完成的任务。在多线程编程...
java 张三和李四的死锁
weixin_30340819的博客
03-13 177
1 class ZhangSan{ 2 public void say(){ 3 System.out.println("Zhang said:you should lend your painting to me!"); 4 } 5 public void get(){ 6 System.out.println("Zhang has ...
转来转去锁（动态死锁）
qq_3316359388的博客
03-01 113
public class TrasnferAccount implements ITransfer { @Override public void transfer(UserAccount from, UserAccount to, int amount) throws InterruptedException { synchronized (fr...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 332
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java多线程编程：死锁的原因与解决策略
"死锁的产生、原因和特性-Java全部课件，涵盖了Java语法基础、面向对象编程、高级编程接口（包括GUI编程、多线程、I/O和网络编程）以及Java语言的知识体系结构图。课程深入讲解了死锁的概念、原因以及如何避免死锁。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值