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");
}
}