生产者消费者模型的信号量+ReentrantLock的实现
生产者消费者模型的信号量+ReentrantLock的实现
Finley.Hamilton 发表于5年前
生产者消费者模型的信号量+ReentrantLock的实现
  • 发表于 5年前
  • 阅读 216
  • 收藏 3
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

package cn.edu.sysu;

import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ObjectQueue{
	
	private final int size=10;
	
	private final Semaphore notEmpty=new Semaphore(0);
	private final Semaphore notFull=new Semaphore(size);
	
	private ArrayList<Integer> ints=new ArrayList<Integer>();
	
	private Lock lock=new ReentrantLock();
	
	public ObjectQueue(){}
	
	public void putItem(Integer i){
		
		try {
			notFull.acquire();
			lock.lock();
			ints.add(i);
			notEmpty.release();
		} catch (Exception e) {
			System.out.println("Exception happened in object queue put item");
		}
		finally{
			lock.unlock();
		}
	}
	
	public Integer getItem(){
		
		try {
			notEmpty.acquire();
			lock.lock();
			Integer i=ints.remove(0);
			notFull.release();
			return i;
		} catch (Exception e) {
			System.out.println("Exception happened in object queue get item");
		}
		finally{
			lock.unlock();
		}
		return null;
	}
}

class Producer extends Thread{
	
	int id;
	ObjectQueue queue;
	public Producer(int i, ObjectQueue q){
		super();
		this.id=i;
		this.queue=q;
	}
	
	public void run() {
		for(int i=0;i<100;i++){
			queue.putItem(new Integer(i+10000));
			System.out.println("Producer "+id+" produce Integer "+(i+10000));
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}


class Consumer extends Thread{
	
	int id;
	ObjectQueue queue;
	public Consumer(int i, ObjectQueue q){
		super();
		this.id=i;
		this.queue=q;
	}
	
	public void run() {
		for(int i=0;i<100;i++){
			Integer item=queue.getItem();
			System.out.println("Consumer "+id+" consume Integer "+item.intValue());
			try {
				Thread.currentThread().sleep(3000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}


public class LockImplmentation {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ObjectQueue queue=new ObjectQueue();
		Producer p=new Producer(1,queue );
		int consumerCount=5;
		Consumer c[]=new Consumer[consumerCount];
		for(int i=0;i<consumerCount;i++){
			c[i]=new Consumer(i, queue);
			c[i].start();
		}
		p.start();
		
	}

}

要把心静下来的话还是应该去写一些基本的程序,虽然很简单,但是不失为笔试面试的有效材料,有点不规范的地方,但是我就是喜欢extends Thread,用Runnable的话好像还是不习惯多写几行。另外的话可以复习一下进程同步的知识


连什么是可重入锁都不知道就在那里瞎写:

可重入锁,最关键的地方是认识他

final Condition con = lock.newCondition();

之后所得到的condition调用await,和直接调用Thread.sleep的区别

前者是lock住了但是不保持这个锁(别人可以保持这个锁,到他回来的时候,就是重入了),后者不光是保持了这个锁,而且lock了这个锁(别人怎么也进不来了)

看这里:http://tenyears.iteye.com/blog/48750


官方:

如果该锁定没有被另一个线程保持,则获取该锁定并立即返回,将锁定的保持计数设置为 1。
如果当前线程已经保持该锁定,则将保持计数加 1,并且该方法立即返回。
如果该锁定被另一个线程保持,则出于线程调度的目的,禁用当前线程,并且在获得锁定之前,该线程将一直处于休眠状态,此时锁定保持计数被设置为 1。

标签: Java 同步 信号量
  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
Finley.Hamilton
粉丝 4
博文 44
码字总数 15431
×
Finley.Hamilton
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: