多线程 - 同步块

package RuntimeOpitimation.syschronized;


public class Counter {


/**
* java同步块基础讲解：
* 第一：java同步块用synchornized标记，同步块是同步到某一对象上的，经常是同步对象的某些

* 方法，当然一个对象有很多方法，也就有很多同步块，但是每次只有一个线程能够在两个同步块中任意一个方法内执行。

也是对象只有一个锁，对于多个线程引用同一个对象时候，无论对象里面有多少个同步块，一旦有一个线程，进入到了任意一个同步块，即获得了当前对象的唯一一把锁，

那么其他的所有线程无论是执行其他的任何一个同步块，都必须处于等待状态，直到线程释放当前对象锁。这也是java的设置机制，同时只能有一个线程可以更改当前对象的

状态。

* 第二：有以下四种不同的同步块
* 1  、实例方法同步块，是经常使用的，如本例子中的代码
* 2、静态方法同步块
* 3、实例方法中的同步块
* 4、实例中的静态同步块
* 注意，同步块，只保护他包含的部分，即同一时间只可以有一个线程来访问当前对象的这个方法，
* 其他线程要访问，必须等待。
* 不难发现，第一和第二个方案效果是相同的，因为无论实力同步块还是实力方法中的同步块，他们
* 锁保护的内容都是相同的，当然，如果保护的内容不相同，当然也就不能有相同的效果了。
* 
* 
*/



/**
* 1、实例方法同步块，是经常使用的，如本例子中的代码
*/
long count = 0;
public synchronized void add(long value){
this.count += value;
}


/**
* 1、实例方法同步块，是经常使用的，如本例子中的代码
* 
*  public synchronized void log2(String msg1, String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }
*/


/*
* 2、静态方法同步块
* 统一时间只可以有一个线程访问此方法
* public synchronized void add(long value){
this.count += value;
}*/


/**
* 3、实例方法中的同步块
* 统一时间只可以有一个线程访问synchronized里面的方法，当然，如果在synchronized
* 外面加上其他的操作，则可以有多个线程同时访问。即同步块只保护他包含的部分
*  public void log2(String msg1, String msg2){
      synchronized(this){
       log.writeln(msg1);
       log.writeln(msg2);
      }
    }


*/

/**
* 4、静态方法中同步块
* 
* public static void log2(String msg1, String msg2){
synchronized(Counter.class){
log.writeln(msg1);
log.writeln(msg2);
}


}
*/

}

#####################################################

package RuntimeOpitimation.syschronized;


public class CounterThread extends Thread{

protected Counter counObj = null;

public CounterThread(Counter obj ){
this.counObj = obj;
}

public void run(){
for(int i = 0;i<10;i++){
counObj.add(i);
}
}
}

########################################################

package RuntimeOpitimation.syschronized;


public class Main {

public static void main(String[] args) {

/**第一种：引用一个对象
* 创建两个线程，他们引用的是一个对象，也就是只有个对象锁，因此，在此种情况下，当两个
* 线程同时访问这个对象的时候，对于同步块，另外一个线程必须等待第一执行完之后才可以再执行
* 
*/
/*Counter conter = new Counter();
Thread threadA = new CounterThread(conter);
Thread threadB = new CounterThread(conter);
threadA.start();
threadB.start();*/



/**
* 第二种：引用两个对象
* 
* 下面代码不难发现，两个线程引用的是两个不同的对象，也就是两个对象锁，而对于
* 同步块，我们已经讲过，它同步的是拥有当前同步块（方法）的对象，也就是只对调用
* 当前方法的对象加锁，因此有两个对象，也就是两把锁，不同的线程虽然是执行同一个
* 方法，但是他们互不影响，依然可以并行执行。
* 
*/

/*Counter conter1 = new Counter();
Counter conter2 = new Counter();
Thread threadA = new CounterThread(conter1);
Thread threadB = new CounterThread(conter2);
threadA.start();
threadB.start();*/

}


}