多线程-ReentrantLock

冷不防 2022-07-15 00:01 195阅读 0赞

package cn.stu;
    
    import java.util.Calendar;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    
    public class MyPlayer implements Runnable {
    
    	private Lock lock;
    	public int data = 100;     // 用于线程同步访问的共享数据  
    
    	public MyPlayer(Lock lock) {
    		this.lock = lock;
    	}
    
    	@Override
    	public void run() {
    
             // playerFree();
    		
             // this.playerOneByOne();
    		
    		 // testLockInterruptibly();
    	}
    
    	
    	//  阻塞进行处理。
    	@SuppressWarnings("unused")
    	private void playerOneByOne(){
    		lock.lock();
    		Calendar now = Calendar.getInstance();  
    		try{
    			data = data + 10; 
    			System.out.println(now.getTime() + " " + Thread.currentThread()+ " accesses the data " + data); 
    			Thread.sleep(1000);  
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally{
    			lock.unlock();
    		}
    	}
    	
        //  如果没有获取到锁，就直接退出，做其他的事情。 
    	@SuppressWarnings("unused")
    	private void playerFree() {
    		try {
    
    			if (this.lock.tryLock(1, TimeUnit.SECONDS)) {
    
    				System.out.println("Thread id--->" + Thread.currentThread().getName());
    
    				Thread.sleep(2000);
    
    			} else {
    
    				System.out.println("不再等待这个锁的到来，完全放弃.--->" + Thread.currentThread().getName());
    			}
    		} catch (InterruptedException e) {
    
    			//System.out.println("我已经出来了啊，不等了， 走了");
    
    		} finally {
    			this.lock.unlock();
    		}
    	}
    	
    	
    	// lockInterruptibly 可被其他线程中段，然后抛异常。 如果没有，就是阻塞形式，和 lock一样。 
    	@SuppressWarnings("unused")
    	private  void  testLockInterruptibly(){
    		
    		try{
    			lock.lockInterruptibly();
    			data = data + 1; 
    			System.out.println("data-->"+data+"---->"+Thread.currentThread().getName());
    			Thread.sleep(4000);
    		}catch(InterruptedException  e){
    			
    			System.out.println("我被中段了......");
    		}finally{
    			lock.unlock();
    		}
    	}
    	
    	//  Condition 这个用法。 相当与原来的 wait()和nofity() 等。 更加的灵活。
    	 
    }

package cn.stu;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /***
     * 
    *    ReentrantLock 的lock机制有2种，忽略中断锁和响应中断锁.
    *    
    *    参考文章： http://uule.iteye.com/blog/1488356 
    *    
    *     
    *    
    *    
    *    
    *
     */
    public class Main {
    
    	public static void main(String[] args) throws InterruptedException {
    		
    		ExecutorService  service = Executors.newFixedThreadPool(4);
    		Lock lock = new ReentrantLock(); 
    		MyPlayer player = new MyPlayer(lock); 
    		for(int i = 0; i<4; i++){
    			service.submit(player);
    		}
    		service.shutdown();
    		 
    	}
    }