同步synchronized

本文参考：http://injavawetrust.iteye.com/blog/2296807
package thread;
/**
* 
* @author InJavaWeTrust
*
*/ 
public class CountVolatile implements Runnable{

    public static CountVolatile instance = new CountVolatile(); 
    public static volatile int i = 0; 
   //静态递增方法
    public static void increate() { 
        i++; 
    }
    //循环调用一千万次递增方法
    public void run() { 
        for (int c = 0; c < 10000000; c++) { 
            increate(); 
        } 
    } 
    //main方法
    public static void main(String[] args) throws InterruptedException { 
    //创建线程
        Thread t1 = new Thread(instance); 
        Thread t2 = new Thread(instance); 
        t1.start(); 
        t2.start(); 
        t1.join(); 
        t2.join(); 
        System.out.println(i); 
    } 
    /**
     *  这段代码演示了一个计数器，两个线程同时对i进行累加，个执行10000000次。
     *  我们希望的执行结果是最终i的值可以达到20000000，但事实并非总是如此。
     *  很多时候，i的值会小于期望的数值20000000。
     *  这是因为两个线程同时对i进行写入时，其中一个线程的结果会覆盖另外一个线程的结果。
     * */
}

关键字synchronized的几种用法。


一、指定加锁对象:对给定对象加锁，进入同步代码钱要获得给定对象的锁。
Java代码  收藏代码
/**
* 
* @author InJavaWeTrust
*
*/ 
public class CountSynchronized implements Runnable { 
    public static CountSynchronized instance = new CountSynchronized(); 
    public static int i = 0; 
    public void run() { 
        for (int c = 0; c < 10000000; c++) { 
            synchronized(instance) { //对给定对象加锁 
                i++; 
            } 
        } 
    } 
     
    public static void main(String[] args) throws InterruptedException { 
        Thread t1 = new Thread(instance); 
        Thread t2 = new Thread(instance); 
        t1.start(); 
        t2.start(); 
        t1.join(); 
        t2.join(); 
        System.out.println(i); 
    } 
} 
 
二、直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

Java代码  收藏代码
/**
* 
* @author InJavaWeTrust
*
*/ 
public class CountSynchronized2 implements Runnable { 
    public static CountSynchronized2 instance = new CountSynchronized2(); 
    public static int i = 0; 
    public synchronized void increate() { //对当前实例方法加锁 
        i++; 
    } 
    public void run() { 
        for (int c = 0; c < 10000000; c++) { 
            increate(); 
        } 
    } 
     
    public static void main(String[] args) throws InterruptedException { 
        Thread t1 = new Thread(instance); 
        Thread t2 = new Thread(instance); 
        t1.start(); 
        t2.start(); 
        t1.join(); 
        t2.join(); 
        System.out.println(i); 
    } 
} 

三、直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

Java代码  收藏代码
/**
* 
* @author InJavaWeTrust
*
*/ 
public class CountStaticMethod implements Runnable { 
    static int i = 0; 
    public static synchronized void increate() { //相当于对当前类加锁 
        i++; 
    } 
    public void run() { 
        for (int c = 0; c < 10000000; c++) { 
            increate(); 
        } 
    } 
     
    public static void main(String[] args) throws InterruptedException { 
        Thread t1 = new Thread(new CountStaticMethod());//new一个对象 
        Thread t2 = new Thread(new CountStaticMethod());//new一个对象 
        t1.start(); 
        t2.start(); 
        t1.join(); 
        t2.join(); 
        System.out.println(i); 
    } 
}