线程同步练习

模拟铁路售票系统,实现通过四个售票点发售100张火车票(即同日同次列车), 一个售票点用一个线程来表示。

package com.gqy;

public class Tickets_Excends_Thread  extends Thread{

	private int tickets = 100;

	public void run(){
		
		while(true){
			
			getTickets();
		}
		
	}
	public  void getTickets(){
		if(tickets > 0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "---" + tickets--);
		}
	}

}
package com.gqy;

public class Tickets_Implements_Runnable_No  implements Runnable{
	private int tickets = 100;

	public void run(){
		
		while(true){
			
			getTickets();
		}
		
	}
	public  void getTickets(){
		if(tickets > 0){
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName() + "---" + tickets--);
		}
	}

}
package com.gqy;

//public class Tickets  extends Thread{

public class Tickets_Implements_Runnable_Yes  implements Runnable{
	private int tickets = 100;

	public void run(){
		
		while(true){
			
			getTickets();

		}
		
	}
	public synchronized void getTickets(){
		if(tickets > 0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "---" + tickets--);
		}
	}

}
package com.gqy;

public class Test_Tickets {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
		//使用继承Thread类的方式实现
		
		Tickets_Excends_Thread tet1 = new Tickets_Excends_Thread();
		Tickets_Excends_Thread tet2 = new Tickets_Excends_Thread();
		Tickets_Excends_Thread tet3 = new Tickets_Excends_Thread();
		Tickets_Excends_Thread tet4 = new Tickets_Excends_Thread();
		tet1.start();
		tet2.start();
		tet3.start();
		tet4.start();
		
		
		
		/*
		//使用实现Runnable接口实现方式,注:没有使用同步方式控制
		Tickets_Implements_Runnable_No tirn = new Tickets_Implements_Runnable_No();
		Thread t1 = new Thread(tirn);
		Thread t2 = new Thread(tirn);
		Thread t3 = new Thread(tirn);
		Thread t4 = new Thread(tirn);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		*/
		
		
		
		//使用实现Runnable接口实现方式,注:使用同步方法控制数据的准确性
		/*
		Tickets_Implements_Runnable_Yes tt = new Tickets_Implements_Runnable_Yes();
		Thread t1 = new Thread(tt);
		Thread t2 = new Thread(tt);
		Thread t3 = new Thread(tt);
		Thread t4 = new Thread(tt);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		*/
		
	}

}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,这是一个典型的生产者-消费者问题,可以使用线程间通信和同步技术来解决。下面是一个简单的实现代码: ```python import threading import time # 定义一个共享数据的数组 data = [] # 定义一个互斥锁,用于保证线程同步 mutex = threading.Lock() # 定义一个生产者线程类 class Producer(threading.Thread): def __init__(self, name): threading.Thread.__init__(self) self.name = name def run(self): global data while True: # 获取互斥锁,保证线程同步 mutex.acquire() # 生产者向数组中写入数据 data.append(1) print("{} 生产者向数组中写入了一个数据,当前数组大小为{}".format(self.name, len(data))) # 释放互斥锁 mutex.release() # 等待一段时间 time.sleep(0.5) # 定义一个消费者线程类 class Consumer(threading.Thread): def __init__(self, name): threading.Thread.__init__(self) self.name = name def run(self): global data while True: # 获取互斥锁,保证线程同步 mutex.acquire() # 判断数组是否为空 if len(data) == 0: print("{} 消费者发现数组为空,等待生产者生产数据".format(self.name)) else: # 消费者从数组中读取数据 data.pop() print("{} 消费者从数组中读取了一个数据,当前数组大小为{}".format(self.name, len(data))) # 释放互斥锁 mutex.release() # 等待一段时间 time.sleep(1) if __name__ == '__main__': # 创建一个生产者线程和一个消费者线程 p = Producer("生产者") c = Consumer("消费者") # 启动线程 p.start() c.start() # 等待线程结束 p.join() c.join() ``` 在上面的代码中,我们定义了一个共享数据的数组 `data` 和一个互斥锁 `mutex`。生产者线程向数组中写入数据,消费者线程从数组中读取数据,并且通过互斥锁保证线程同步。在生产者线程中,首先获取互斥锁,然后向数组中写入数据,最后释放互斥锁。在消费者线程中,首先获取互斥锁,然后判断数组是否为空,如果为空,则输出提示信息,等待生产者生产数据;否则,从数组中读取数据,最后释放互斥锁。通过这种方式,我们实现了线程的同步,并且避免了生产者和消费者之间的竞争和冲突。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值