Java中synchronized关键字理解-优快云博客

好记性不如烂笔头~~

并发编程中synchronized关键字的地位很重要，很多人都称它为重量级锁。利用synchronized实现同步的基础：Java中每一个对象都可以作为锁。具体表现为以下三种形式。

（1）对于普通同步方法，锁是当前实例对象。

（2）对于静态同步方法，锁是当前类的Class对象。

（3）对于同步方法块，锁是synchronized括号里配置的对象。

一、普通同步方法

使用synchronized关键字修饰一个普通方法，锁住的是当前实例的对象。当synchronized锁住该对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。

实验一

class Synch{
	public synchronized  void test1(){
		System.out.println("test1开始");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("test1结束");
	}
	public synchronized void test2(){
		System.out.println("test2开始");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("test2结束");
	}
}

public class SyncTest extends Synch{
	
   public static void main(String args[]){
	   Synch s=new Synch();
	   Thread t1=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			s.test1();
		}
		   
	   });
	   Thread t2=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			s.test2();
		}});
	   t1.start();
	   t2.start();
   }
}

　　实验结果：

分析上述代码，类Synch中有两个普通同步方法test1和test2.在主函数中实现了该类，同时定义两个thread线程，run方法中分别调用类Synch的方法。synchronized实现的普通同步方法，锁住的是当前实例对象，即Synch类对象。由于两个线程是调用的同一个对象中的同步方法，所以只有一个线程释放该对象的锁，另一个线程才能调用。

实验二

class Sync{
	public synchronized void test(String threadname){
		
		System.out.println(threadname+"开始");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(threadname+"结束");

	}
}
class MyThread extends Thread{
	public int i;
	public MyThread(int i){
		this.i=i;
	}
	Sync s=new Sync();
	public void run(){		
		//Sync sync=new Sync();
		s.test("Thread"+i);
	}
}
public class SynTest {
    public static void main(String args[]){
    	for(int i=0;i<3;i++){
			Thread thread=new MyThread(i);
			thread.start();
		}
    }
}

　实验结果：

上述代码，每个线程中都new了一个Sync类的对象，也就是产生了三个Sync对象，由于不是同一个对象，所以可以多线程同时运行synchronized方法。

二、静态同步方法

对于静态同步方法，锁是当前类的Class对象，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。只有一个线程结束后，另一个线程才能获得锁。

实验三

class Synch{
	public static synchronized  void test1(){
		System.out.println("test1开始");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("test1结束");
	}
	public static synchronized  void test2(){
		System.out.println("test2开始");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("test2结束");
	}
}

public class SyncTest extends Synch{
	
   public static void main(String args[]){
	   Synch s1=new Synch();
	   Synch s2=new Synch();
	   Thread t1=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			s1.test1();
		}
		   
	   });
	   Thread t2=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			s2.test2();
		}});
	   t1.start();
	   t2.start();
   }
}

　　实验结果：

三、同步方法块

这部分更好理解，锁住的是synchronized括号里配置的对象。

实验四

public class Threadtest implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		synchronized(this){
			  for (int i = 0; i < 5; i++) {  
                  System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
             }  
		}
	}
	public static void main(String[] args) {  
        Threadtest t1 = new Threadtest();  
        Thread ta = new Thread(t1, "A");  
        Thread tb = new Thread(t1, "B");  
        ta.start();  
        tb.start();  
   } 
}

运行结果：

上述代码，synchronized代码块括号里配置的对象是this，同一个对象，所以只有一个线程访问该代码块结束后，释放锁，另一个线程才能访问该代码块。

需要注意的是，其他线程可以访问非synchronized（this）同步代码。如下代码

实验五

class MyThread1{
	public void test1(){
    	synchronized(this){
    		System.out.println("同步代码块-test1开始");
    		try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    		System.out.println("同步代码块-test1结束");
    	}
    }
    public void test2(){
    	try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	System.out.println("非同步代码块-test2");
    }
}
public class ThreadTest1 {
	public static void main(String args[]){
    MyThread1 t=new MyThread1();
    Thread t1=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			t.test1();
		}
    	
    });
    Thread t2=new Thread(new Runnable(){

		@Override
		public void run() {
			// TODO Auto-generated method stub
			t.test2();
			
		}
    	
    });
    t1.start();
    t2.start();
	}
}

　　运行结果：