java线程的同步

 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。按照这个定义，其实绝大多数函数都是同步调用（例如sin, isdigit等）。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。例如Window API函数SendMessage。该函数发送一个消息给某个窗口，在对方处理完消息之前，这个函数不返回。当对方处理完毕以后，该函数才把消息处理函数所返回的LRESULT值返回给调用者。
 在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
 也就不多说了，直接贴代码

Hero类

package synchronizedThread;

public class Hero {
    public String name;
    public int hp;
    public int damage;

    public Hero(){

    }

    public Hero(String name,int hp,int damage){
        this.name = name;
        this.hp = hp;
        this.damage = damage;
    }

    /*
    public void attackHero(Hero h){
        try{
            //为了表示攻击需要时间，用1000毫秒
            Thread.sleep(1000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        h.hp -= damage;
        if(h.hp<0) h.hp = 0;
        System.out.format("%s 正在攻击  %s,%s 的血变成了  %d\n",name,h.name,h.name,h.hp);

        if(h.isDead()){
            System.out.println(h.name+"死了！");
        }
    }

    public boolean isDead(){
        return 0>=hp?true:false;
    }
    */

    public void recover(){
        hp+=1;
        System.out.printf("回复，hp:%d\n",hp);
    }

    public void hurt(){
        hp-=1;
        System.out.printf("被攻击，hp:%d\n",hp);
    }
}

测试类

package synchronizedThread;


public class TestSynchronized {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Hero hero = new Hero("盖伦",400,10);
        int n = hero.hp;

        Thread[] add = new Thread[400];
        Thread[] sub = new Thread[400];


        for(int i =0;i<n;i++){
             Thread recover = new Thread(){
                public void run(){
                    //这里加上synchronized与在方法recover前加synchronized是一样的效果
                    synchronized (hero) {             
                        hero.recover(); 
                    }
                }
             };
             recover.start();
             add[i] = recover;
        }

        for(int i =0;i<n;i++){
            Thread hurt = new Thread(){
                public void run(){
                    synchronized (hero) {
                        hero.hurt();    
                    }
                }
            };
            hurt.start();
            sub[i] = hurt;
        }

        for(Thread thread:sub){
            try{
                thread.join();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }

        for(Thread thread:add){
            try{
                thread.join();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }


        System.out.printf("%d次攻击，%d次回复，最终:盖伦的血量为 %d\n",n,n,hero.hp);

    }

}

结果 （最后部分）