关于java的锁

 

package com.lhy;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class A {
	static A a=new A();
	public static void main(String[] args) {
		new Thread(){
            public void run() {
                a.add();
            };
        }.start();
        
       
        
        new Thread(){
            public void run() {
                a.add1();
            };
        }.start();
        
        new Thread(){
            public void run() {
                a.add2();
            };
        }.start();
        
        new Thread(){
            public void run() {
                a.add3();
            };
        }.start();
        
        
        new Thread(){
            public void run() {
                a.add4();
            };
        }.start();
        
        new Thread(){
            public void run() {
                a.add5();
            };
        }.start();
	}
	Lock lock = new ReentrantLock();    //注意这个地方,类变量不能定义在方法中
    
	/**
	 * 普通锁块
	 */
	void add(){
		int i=0;
		synchronized(this){
		while(true){
			if(i==5)
				break;
			i++;
			System.out.println("****synchronize块锁:"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		}
	}
	/**
	 * 普通方法锁
	 */
	 synchronized void add1(){
		int i=0;
		while(true){
			if(i==5)
				break;
			
			i++;
			System.out.println("****synchronized方法锁:"+i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
	 	/**
		 * 普通lock锁
		 */
	  void add2(){
			int i=0;
			lock.lock();
			while(true){
				if(i==5)
					break;
				
				i++;
				System.out.println("####ReentrantLock锁:"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			lock.unlock();
		}
	  /**
		 * 普通lock锁
		 */
	  void add3(){
			int i=0;
			lock.lock();
			while(true){
				if(i==5)
					break;
				
				i++;
				System.out.println("####ReentrantLock锁:"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			lock.unlock();
		}
	  
	  ReentrantReadWriteLock  wrlock1=new ReentrantReadWriteLock();
	  /**
		 * 读锁
		 */
	  void add4(){
			int i=0;
			wrlock1.readLock().lock();
			while(true){
				if(i==5)
					break;
				
				i++;
				System.out.println("*****ReentrantReadWriteLock的read锁:"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			wrlock1.readLock().unlock();
		}
	  /**
		 * 写锁
		 */
	  
	  void add5(){
			int i=0;
			wrlock1.writeLock().lock();
			while(true){
				if(i==5)
					break;
				
				i++;
				System.out.println("ReentrantReadWriteLock的write锁:"+i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			wrlock1.writeLock().unlock();
		}
}

输出结果

****synchronize块锁:1
####ReentrantLock锁:1
*****ReentrantReadWriteLock的read锁:1
****synchronize块锁:2
####ReentrantLock锁:2
*****ReentrantReadWriteLock的read锁:2
****synchronize块锁:3
####ReentrantLock锁:3
*****ReentrantReadWriteLock的read锁:3
****synchronize块锁:4
####ReentrantLock锁:4
*****ReentrantReadWriteLock的read锁:4
****synchronize块锁:5
####ReentrantLock锁:5
*****ReentrantReadWriteLock的read锁:5
****synchronized方法锁:1
####ReentrantLock锁:1
ReentrantReadWriteLock的write锁:1
****synchronized方法锁:2
####ReentrantLock锁:2
ReentrantReadWriteLock的write锁:2
****synchronized方法锁:3
####ReentrantLock锁:3
ReentrantReadWriteLock的write锁:3
****synchronized方法锁:4
####ReentrantLock锁:4
ReentrantReadWriteLock的write锁:4
****synchronized方法锁:5
####ReentrantLock锁:5
ReentrantReadWriteLock的write锁:5

 

总结：

（1）synchronized ：对于多个线程同时访问synchronized 修饰的，不管是方法还是代码块，只要一个线程进入其中一个synchronized修饰的方法或块，其他线程就不能进入此类下任何synchronized修饰的方法或块。

（2）ReentrantLock：对于多个线程同时访问ReentrantLock修饰代码块，只要一个线程获得ReentrantLock的lock()，在此线程unlock()前，其他线程就不能进入此类下任何ReentrantLock.lock()。

（3）ReentrantReadWriteLock：对于read锁，多个线程可以同时访问read锁，但如果其中一个线程获得write锁，其他线程都不能进入此类下的任何write.lock()或者read.lock()

    即：多个读锁不互斥。读写，写写互斥（互斥效果同1,2）

以上三种锁机制不互斥

以上所有都是多个线程针对同一个类中的锁。