线程的同步互斥

1、多线程打印屏幕，出现不可预想的结果

package cn.itcast.thread;

public class ThreadSynchronized {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //final InnerOutput inneroutput=new InnerOutput();

        //静态方法中不能new内部类的实例对象，静态方法可以不用创建实例就可以访问的

        //但是内部类要依赖于外部类的实例，矛盾

        new ThreadSynchronized().init();
    }

    public void init(){
        final InnerOutput inneroutput=new InnerOutput();
        new Thread(new Runnable(){
            @Override
            public void run(){
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block

                        e.printStackTrace();
                    }
                    inneroutput.output("zhangxiaoxiang");
                }
            }
        }).start();

        new Thread(new Runnable(){
            @Override
            public void run(){
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block

                        e.printStackTrace();
                    }
                    inneroutput.output("lihuoming");
                }
            }
        }).start();
    }
    class InnerOutput{
        public void output(String name){
            int len=name.length();
            for(int i=0;i<len;i++){
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

输出：
zlihuohangxiaoxiangming

lihuoming
zhangxiaoxiang
lihuoming

关键是找一把共同的锁

1、Synchronized修饰方法与代码块，方法用的就是this,而代码块用的不一定是this,如果是this,则这个方法与那段代码块也能同步了。

2、Synchronized修饰代码块时，Synchronized(object)object只要是对象就行，如果不用this(因为不同一把锁),这样创建多个实例时，同步根本不能起作用

class InnerOutput{
        /**
         * 用synchronized修饰方法后，这段打印代码就能同步，
         * 一个线程执行完，另外一个线程才能执行
         * @param name
         */
        public synchronized void output(String name){
            int len=name.length();
            for(int i=0;i<len;i++){
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }

输出：
zhangxiaoxiang
lihuoming
zhangxiaoxiang
lihuoming
zhangxiaoxiang
lihuoming
zhangxiaoxiang
lihuoming
zhangxiaoxiang
lihuoming
zhangxiaoxiang
lihuoming

class InnerOutput{

        public void output(String name){
            int len=name.length();
            /**
             * 用synchronized修饰方法，这段打印代码就能同步，
             * 这个this，代表同一把锁，也可以用name,但是这样的话传入不同的name,就不能同步
             *就算是this,创建多个InnerOutput实例，也不是同一把锁(比如创建两个放在不同的线程上           *跑)，解决的话只有用类.class等共同的内存，看需求
             *
             * @param name
             */
            synchronized (this) {
                for(int i=0;i<len;i++){
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }

        }
    }