好记性不如烂笔头~~

并发编程中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();

}

}

运行结果：

synchronized括号里配置的是this，只是对这一段代码进行了加锁，同一个对象，只有一个线程能访问该代码块，释放锁之后，其他线程才可以访问，但是并不影响其他线程访问非同步代码块。

同步代码块，同步方法的实现~~简单理解

对于同步代码块是使用monitorenter、monitorexit指令实现的。每个对象都有一个监视器锁(monitor)，当monitor被占用时，就会处于锁定状态。

线程执行monitorenter指令尝试获取monitor的所有权。

如果monitor的进入数为0，则该线程进入monitor，并将进入数设置为1

如果该线程已经占有了该monitor，重新进入，进入数也要+1

如果其他线程占用了monitor，则该线程进入阻塞状态，知道进入数为0

对于同步方法，常量池中多了ACC_SYNCHRONIZED标识符，方法调用时，先检查该标识符的访问标志，如果设置了，则进程先获取monitor，获取成功后才能执行方法体，方法执行完之后再释放monitor。