2、传统的线程互斥synchronized

synchronized使用之基本原则：

synchronized可以锁方法，也可以锁代码片段，但要实现互斥的基本就是在想要互斥的代码上加”同一把锁“，也就是同一个对象，也就是用==判断等于true的对象

下面看一个例子：

Work.java    真正做事情的类

package com.yzl;

public class Work {
    /**
     * 未同步的
     * @param name
     */
    public void noSynwrite(String name){
        for(int i=0; i<name.length(); i++){
            System.out.print(name.charAt(i));
            if(i == (name.length()-1)){
                System.out.print("
");
            }
        }
    }
    
    /**
     * 使用同步块，并使用Work的实例对象做为锁
     * 此方法的同步需保证是调用该方法的work对象是同一个
     * @param name
     */
    public void write1(String name){
        synchronized (this) {
            for(int i=0; i<name.length(); i++){
                System.out.print(name.charAt(i));
                if(i == (name.length()-1)){
                    System.out.print("
");
                }
            }
        }
    }
    
    /**
     * 使用同步块，并使用Work的字节码做为锁
     * @param name
     */
    public void write1WithStatic(String name){
        synchronized (Work.class) {
            for(int i=0; i<name.length(); i++){
                System.out.print(name.charAt(i));
                if(i == (name.length()-1)){
                    System.out.print("
");
                }
            }
        }
    }
    
    /**
     * 使用同步的方法，锁对象为ork的实例对象
     * 此方法的同步需保证是调用该方法的work对象是同一个
     * @param name
     */
    public synchronized void write2(String name){
        for(int i=0; i<name.length(); i++){
            System.out.print(name.charAt(i));
            if(i == (name.length()-1)){
                System.out.print("
");
            }
        }
    }
    
    /**
     * 静态方法的同步方法，同步的对象是对象的字节码，也就是Work.class
     * 如果要与上面的方法一起使用并保持互斥，则可以把write1的锁对象this改成Work.class
     * @param name
     */
    public synchronized static void write3(String name){
        for(int i=0; i<name.length(); i++){
            System.out.print(name.charAt(i));
            if(i == (name.length()-1)){
                System.out.print("
");
            }
        }
    }
}

测试类ThreadPart_2.java

package com.yzl;

/**
 * 传统的线程互斥
 * 原理：使用同一个对象（锁）才能实现，
 *         静态方法的同步则只能使用类的字节码也就是ClassName.class来做锁
 * @author yzl
 *
 */
public class ThreadPart_2 {
    public static void main(String[] args) {
        noSyn();
        synWithOneObj();
        synWithOneStaticObj();
    }
    
    /**
     * 未线程同步的
     */
    private static void noSyn(){
        final Work work = new Work();
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    work.noSynwrite("wangwu");
                }
            }
        });
        thread.start();
        
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    work.noSynwrite("zhangsan");
                }
            }
        });
        thread1.start();
    }
    
    /**
     * 使用同一个实例对象做为锁的
     */
    private static void synWithOneObj(){
        final Work work = new Work();
        
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    work.write1("wangwu");
                }
            }
        });
        thread.start();
        
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    work.write2("zhangsan");
                }
            }
        });
        thread1.start();
    }
    
    /**
     * 使用同一个类的字节码做为锁的
     */
    private static void synWithOneStaticObj(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    new Work().noSynwrite("wangwu");
                }
            }
        });
        thread.start();
        
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    Work.write3("zhangsan");
                }
            }
        });
        thread1.start();
    }
}

将上面ThreadPart_2的第12、13、14行代码分别依次执行，

第12行代码将出现如下类似结果：

//运行结果部分示例
zhangsan
zhwu
wangwu
wangangsan
zhangsawangwu

第13和14行将是正常的打印各自的名字