使用synchronized关键字来解决并发线程互斥

在多个线程同时操作同一资源的时候，就会遇到并发的问题，如银行转账等。为了避免这些问题的出现，我们可以使用synchronized关键字来解决，下面针对synchronized常见的用法。

/**
 * 使用synchronized关键字来解决并发问题 使线程之间互斥
 * @author Administrator
 *
 */
public class ThreadSynchronized {
    public static void main (String [] args){
        //静态方法中不能new内部的实例对象
//      private Outputer outputer = new Outputer();
        new ThreadSynchronized().init();

    }
    private void init(){
        final Outputer outputer = new Outputer();
        //线程1
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//                  outputer.output("abcdefg");
//                  outputer.output1("abcdefg");
//                  outputer.output2("abcdefg");
                    outputer.output3("abcdefg");
                }

            }
        }).start();
        //线程2
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//                  outputer.output("ABCDEFG");
//                  outputer.output1("ABCDEFG");
//                  outputer.output2("ABCDEFG");
                    outputer.output3("ABCDEFG");
                }

            }
        }).start();
    }

    static class Outputer {
        //打印字符
        public void output(String name){
                for (int i = 0; i < name.length(); i++) {
                    System.out.println(name.charAt(i));
                }
                System.out.println();
            }
        private String token = "";
        //打印字符
        public void output1(String name){
            //token对象对于两个线程是同一个,name就不可以因为value是动态的
            synchronized (token){
            for (int i = 0; i < name.length(); i++) {
                System.out.println(name.charAt(i));
            }
            System.out.println();
            }
        }
        //打印字符
        public synchronized void output2(String name){
                for (int i = 0; i < name.length(); i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
        }
        //打印字符
        public static synchronized void output3(String name){
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
     }
}

　　在内部类Outputer中定义了一个打印字符串的方法，一个字符一个字符的打印，字符顺序打乱了就说明出现问题了。然后在init方法中开启两个线程，一个线程打印“abcdefg”，另一个线程打印“ABCDEFG”。

ABCDEabcdefg
FG
ABabCDEFG
cdefg
ABCDEFG
abcdefg
ABCDEFGabcdefg

问题出现了，解决方法，可以使用synchronized同步代码块来对公共部分进行同步操作，但是需要给它一把锁，这把锁是一个对象，可以是任意一个对象，但是前提是，两个线程使用的必须是同一个对象锁才可以，这很好理解。那么下面在output1()方法中加入synchronized代码块：

        private String token = "";
        //打印字符
        public void output1(String name){
            //token对象对于两个线程是同一个,name就不可以因为value是动态的
            synchronized (token){
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
            }
        }

修改后线程安全问题就基本解决了，但是还可以再往下引申，如果在方法上加synchronized关键字的话，那么这个同步锁是什么？我们在Outputer类中再写一个output2()方法：

    private String token = "";
        //打印字符
        public void output1(String name){
            //token对象对于两个线程是同一个,name就不可以因为value是动态的
            synchronized (token){
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
            }
        }
        //打印字符
        public synchronized void output2(String name){
                for (int i = 0; i < name.length(); i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
        }

方法内部实现逻辑一模一样，唯一不同的就是synchronized加在了方法上，那么我们让init()方法中的两个线程中，一个调用output1(String name)方法，另一个调用output2(String name)方法，从结果中能看出，线程安全问题又出现了。产生问题的原因不难发现：现在两个方法都加了synchronized，但是两个线程在调用两个不同的方法还是出现了问题，也就是说，还是各玩各的……那么问题就出在这个锁上，说明两者并没有使用同一把锁！
　　如果我们把output1()方法中synchronized中的token改成this，再运行就没问题了，这说明一点：synchronized关键字修饰方法的时候，同步锁是this，即等效于代码块synchronized(this) {…}。
　　再继续往下引申，现在在Outputer类中再写一个静态方法output3(String name)，并且也让synchronized去修饰这个静态方法。

　　private String token = "";
        //打印字符
        public void output1(String name){
            //token对象对于两个线程是同一个,name就不可以因为value是动态的
            synchronized (token){
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
            }
        }
        //打印字符
        public static synchronized void output3(String name){
            for (int i = 0; i < name.length(); i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

然后在init()方法中一个线程调用output1()方法，另一个线程调用output3()方法。毫无疑问，肯定又会出现线程安全问题。但是如何解决呢？因为static方法在类加载的时候就加载了，所以这个锁应该是类的字节码对象。那么将token改为Outputer.class就解决问题了，这说明一点：synchronized关键字修饰static方法的时候，同步锁是该类的字节码对象，即等效于代码块synchronized(classname.class) {…}。

同步代码块的锁是任意对象。只要不同的线程都执行同一个同步代码块的时候，这个锁随便设。
同步函数的锁是固定的this。当需要和同步函数中的逻辑实行同步的时候，代码块中的锁必须为this。
静态同步函数的锁是该函数所属类的字节码文件对象。该对象可以用this.getClass()方法获取，也可以使用 当前类名.class 表示