JAVA synchronized正确理解

昨天看blog：http://blog.csdn.net/zyplus/article/details/6672775有这样一段话

“在JAVA中，是没有类似于PV操作、进程互斥等相关的方法的。JAVA的进程同步是通过synchronized()来实现的，需要说明的是，JAVA的synchronized()方法类似于操作系统概念中的互斥内存块，在JAVA中的Object类型中，都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。明白这个原理，就能理解为什么synchronized(this)与synchronized(static XXX)的区别了，synchronized就是针对内存区块申请内存锁，this关键字代表类的一个对象，所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，在同一时间只有一个线程可访问该类的实例。如果只是简单的想要实现在JAVA中的线程互斥，明白这些基本就已经够了。但如果需要在线程间相互唤醒的话就需要借助Object.wait(), Object.nofity()了。”

写的非常不错，这里画个图，补充个测试程序。

也就是分清楚到底锁住的是那一部分内存，也就是类和类的实例 内存关系。

测试程序如下:

package com.jdcloud.xue.gang;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class StaticMutiThread extends Thread{

public static final int SIZE=100;

//做个静态锁出来

static final Object LOCKER = new Object();

static int addint =0;

ExecutorService executor;

CountDownLatch countDownLatch;

public StaticMutiThread(ExecutorService executor,

CountDownLatch countDownLatch) {

super();

this.executor = executor;

this.countDownLatch = countDownLatch;

}

public void addPrint(){

synchronized (LOCKER) { //把这里的LOCKER换成this，来测试多个Thread同步试一试

try {

Thread.sleep(100L);

} catch (InterruptedException e) {

e.printStackTrace();

}

addint +=1;

System.out.println("add int is :" + addint);

countDownLatch.countDown();

}

}// //锁住实例化出来的对象的内存。

public void run() {

addPrint();

}

class Runner{

public void runit(StaticMutiThread staticMutiThread){

executor.execute(staticMutiThread);

}

}

//测试Main方法

public static void main(String args[]) throws InterruptedException{

//用于关闭线程池

 CountDownLatch countDownLatch = new CountDownLatch(SIZE);

//线程池

 ExecutorService executor = Executors.newFixedThreadPool(SIZE);

 

for(int i =0;i<SIZE;i++){

//new一个线程出来

StaticMutiThread staticMutiThread = new StaticMutiThread(executor,countDownLatch);

//只是为了把线程加入到线程池

StaticMutiThread.Runner runner = staticMutiThread.new Runner();

runner.runit(staticMutiThread);

}

//运行直到关闭

countDownLatch.await();

executor.shutdown();

}

}

这段程序中生成了多个实例（多个this）,如果在多个实例共有的静态区上加锁，可以协调多个实例，如果只在this上加上，则不行。

-----2014年3月17日

package com.zxg.test;

public  class StaticClassTest{

//如果在方法上加上synchronized 相当于：synchronized (StaticClassTest.class) 

//如果一个sync*方法锁住了一个方法没有释放锁，就会影响到其他方法。

//比如网络sync*方法中有网络连接，慢速攻击？

public static   synchronized   void pring_1(){

int i=10;

while(i>0){

System.out.println("---(1)-->"+i);

try {

Thread.currentThread().sleep(10L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

i--;

}

}

public static  void pring_2(){

synchronized (StaticClassTest.class) {

int i=10;

while(i>0){

System.out.println("---(2)-->"+i);

try {

Thread.currentThread().sleep(100L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

i--;

}

}

}

public static void main(String args[]){

//test 1

new Thread(new Runnable(){

@Override

public void run() {

StaticClassTest.pring_2();

}

}).start();

//test 1

new Thread(new Runnable(){

@Override

public void run() {

StaticClassTest.pring_1();

}

}).start();

System.out.println("12312312");

}

}

转载于:https://my.oschina.net/u/177808/blog/182842