Java传统线程互斥技术

Java多线程基础（三）Java传统线程互斥技术

java的线程互斥主要通过synchronized关键字实现。下面的示例代码展示了几种使用synchronized关键字的基本用法。

package com.ming.thread;

public class TestThread {
    public static void main(String[] args) {
        TestThread test=new TestThread();
        test.init();
        //test.init1();
    }
    private void init(){

        new Thread(new Runnable() {

            @Override
            public void run() {
                 while(true) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //num.sayHello("123456789");
                        //num.sayHello1("123456789");
                        //num.sayHello3("123456789");
                        //num.sayHello4("123456789");
                        final Num num=new Num();
                        num.sayHello5("123456789");
                    }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                 while(true) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //num.sayHello("chenhuaming");
                        //num.sayHello1("chenhuaming");
                        //num.sayHello3("chenhuaming");
                        //num.sayHello4("chenhuaming");
                        final Num num=new Num();
                        num.sayHello5("chenhuaming");
                    }
            }
        }).start();
    }

    private void init1(){
        new Thread(new Runnable() {

            @Override
            public void run() {
                 while(true) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //Num.sayHello11("123456789");
                        Num.sayHello12("123456789");
                    }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                 while(true) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //Num.sayHello11("chenhuaming");
                        Num.sayHello12("chenhuaming");
                    }
            }
        }).start();
    }

    static class Num{
        String _lock ="";
        final static String final_lock="";

        //线程不安全
        /*
         * 多个操作者（线程）必须操作同一个对象
         */
        public void sayHello(String name){
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
        //线程不安全
        /*
         * 原因：
         * 锁对象不互斥，锁对象应该使用共享对象
         * 解决方案如：sayHello2 sayHello3 sayHello4
         */
        public void sayHello1(String name){
            synchronized (name) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }
        //线程安全
        /*
         * 方法1：
         * 
         * 使用共享类对象作为对象锁
         */
        public void sayHello2(String name){
            synchronized (this) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }
        //线程安全
        /*方案2：
         * 
         * 以自定义对象作为锁对象，
         * 与使用_lock加锁的代码块互斥
         */
        public void sayHello3(String name){
            synchronized (_lock ) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }
        //线程安全
        /*
         * 同步方法
         */
        public synchronized void sayHello4(String name){
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

        public void sayHello5(String name){
            synchronized (Num.class) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }

        /**************静态方法************/
        //线程不安全
        public static void sayHello11(String name){
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
        //线程安全
        public static void sayHello12(String name){
            synchronized (final_lock) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }

        }
        //线程安全
        public static void sayHello13(String name){
            synchronized (Num.class) {
                int len = name.length();
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }
        //线程安全
        public synchronized static void sayHello14(String name){
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

}

上面的代码中展示了三种基本的线程互斥实现。下面详述三种方法的实现特点和适用情况。

以this作为锁对象
实现方式
synchronized(this){…}
synchronized实例方法
适用情况
适用于使用类的同一个实例（对象）作为锁对象。下面情况不适用：
若上述代码中第26行和第39行，改为
new Printer().output(“<相应字符串>”);
则无法使用本方法实现线程互斥，而须采用第2种方法。

以Outputer.class作为锁对象
Outputer类的字节码对象由jvm自动加载。
实现方式
synchronized(Outputer.class){…}
static synchronized方法
适用情况
适用于整个类的所有对象都需要互斥访问的情况。

以自定义的对象作为所对象
实现方式
synchronized(<自定义锁对象>){…}
适用情况
同一个类中代码块或者方法的互斥，一般可以用第1种和第2种方法替换。当出现需要在多个类（或者多个类的实例）之间进行互斥控制时，可能需要采用本方法。