JAVA - 线程之方法同步

小华是个3岁的孩子，刚刚学会从1数到100，我们分别启动两个线程，在每个线程里都让小华从1数到100，在不对线程进行同步的情况下，刚刚学会数数的小华数乱了。。

package intro.thread;

class Child{
    public void count(){
        for(int i = 0; i < 100; i++){
            System.out.println(i);
        }
    }
}

class ThreadA extends Thread{
    private Child Child = null;
    public ThreadA(Child Child){
        this.Child = Child;
    }

    public void run(){
        Child.count();
    }

}


public class ThreadTest {
    public static void main(String [] args){
        Child Child = new Child();
        ThreadA A1 = new ThreadA(Child);
        ThreadA A2 = new ThreadA(Child);

        A1.start();
        A2.start();
    }
}

结果：

1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
91 92 93 94 95 96 97 98 99 100

那么如何让宝宝能顺利的数完2遍呢？只好让他先数完第一遍，再数第二遍了

把Child类的Count方法改为：

public synchronized void count(){
        StringBuffer sb = new StringBuffer();
        for(int i = 1; i <= 100; i++){
            //System.out.println(i);
            sb.append(i);，
            sb.append(" ");
            if(i % 10 == 0){
                System.out.println(sb.toString());
                sb.delete(0, sb.toString().length());
            }
        }
    }

这样synchronized锁定的是调用count这个同步方法的对象，所以在A1线程中，宝宝开始从1开始数，
这时候A2线程中，宝宝也准备开始数，但是这个方法由于已经被synchronized， 所以只能等A1中
宝宝数完后，再继续运行。
注意的是，对于方法进行synchronized， 锁定的是同一个访问这个方法的对象。如果有两个宝宝都从
1数到100，那么将会发生什么呢？

package intro.thread;

class Child{
    public synchronized void count(){
        StringBuffer sb = new StringBuffer();
        for(int i = 1; i <= 100; i++){
            //System.out.println(i);
            sb.append(i);
            sb.append(" ");
            if(i % 10 == 0){
                System.out.println(sb.toString());
                sb.delete(0, sb.toString().length());
            }
        }
    }
}

class ThreadA extends Thread{
    private Child Child = null;
    public ThreadA(Child Child){
        this.Child = Child;
    }

    public void run(){
        Child.count();
    }

}


public class ThreadTest {
    public static void main(String [] args){
        Child Child1 = new Child();
        Child Child2 = new Child();
        ThreadA A1 = new ThreadA(Child1);
        ThreadA A2 = new ThreadA(Child2);

        A1.start();
        A2.start();
    }
}

结果：

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100

可以看到，对于两个不同的宝宝，线程不能同步。

那么对于两个不同的宝宝，也想对线程进行同步，让其中一个宝宝数完后，下一个宝宝再继续数，该如何呢？
那么需要对Child类做如下修改：

class Child {

    static Object obj = new Object();

    public void count() {
        synchronized (obj) {  //必须是对静态对象加锁
            StringBuffer sb = new StringBuffer();
            for (int i = 1; i <= 100; i++) {
                // System.out.println(i);
                sb.append(i);
                sb.append(" ");
                if (i % 10 == 0) {
                    System.out.println(sb.toString());
                    sb.delete(0, sb.toString().length());
                }
            }
        }
    }
}