java多线程系列1：Sychronized关键字

1.Synchronized使用范围：

• 同步普通方法：锁的是当前对象

　　　　

//包含synchronized修饰的同步方法的类addCountClass
public class addCountClass {

    private  int count = 0;
    
    synchronized public void addCount(String user) 
    {
        try 
        {
            if(user.equals("a")) 
            {
                count = 100;
                System.out.println("a set count = 100,over");
                Thread.sleep(3000);
            }else 
            {
                count = 200;
                System.out.println("b set count = 200,over");
            }
            System.out.println(user+" count = "+count);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
}

//线程类A
public class ThreadA extends Thread {
    private addCountClass addcount1;
    public ThreadA(addCountClass addcount) 
    {
        super();
        this.addcount1 = addcount;
    }
    
    public void run() 
    {
        super.run();
        addcount1.addCount("a");
    }
}

//线程类B
public class ThreadB extends Thread {
    private addCountClass addcount2;
    public ThreadB(addCountClass addcount) 
    {
        super();
        this.addcount2 = addcount;
    }
    
    public void run() 
    {
        super.run();
        addcount2.addCount("b");
    }
    
}

//测试类
public class MainClass {

    public static void main(String[] args) {
        
        addCountClass addCount1 = new addCountClass();
        addCountClass addCount2 = new addCountClass();
        //线程th1启动后，调用addCount方法时，是用对象addCount1来调用的
        Thread th1 = new ThreadA(addCount1);
        
        //线程th2启动后，调用addCount方法时，是用对象addCount2来调用的
        Thread th2 = new ThreadB(addCount2);
        
        th1.start();
        th2.start();

    }

}

//输出结果
a set count = 100,over
b set count = 200,over
b count = 200
a count = 100

/*分析上述结果可知，因为类中Synchronized关键字修饰的是普通方法，
 *因此锁定的是当前的对象，所以两次调用时分别锁定了addCount1和
 *addCount2，所以两个线程都能够正常访问，互不影响
*/

 

• 同步静态方法：锁的是当前class（类）对象

//将上一个例子中的addCount方法修改为类中的static方法
public class addCountClass {

    private static  int count = 0;
    
    synchronized public static void addCount(String user) 
    {
        try 
        {
            if(user.equals("a")) 
            {
                count = 100;
                System.out.println("a set count = 100,over");
                Thread.sleep(3000);
            }else 
            {
                count = 200;
                System.out.println("b set count = 200,over");
            }
            System.out.println(user+" count = "+count);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//运行结果
a set count = 100,over
a count = 100
b set count = 200,over
b count = 200

/*
 *此时可以看到，执行结果只可能是一个线程完全执行完addCount方法后
 *另一个线程才能够进入该方法，这是因为此时Synchronized修饰的是类
 *中的静态方法，因此锁定的当前的class对象，即当前类。因此无论是
 *addCount1还是addCount2来调用addCount方法，都会锁定当前类对象
*/

 

• 同步代码块：锁的是（）中的对象，synchronized(this)代码块也是锁定当前对象

　　当某个需要同步的方法中并不是所有的部分都需要同步时，可将需要同步的代码块用synchronized来修饰，可以提高程序并发效果。

//案例1，整个方法都加上了Syncchronized关键字
public class Task {
    
    private int a = 0;
    synchronized public void longTimeTask() 
    {
        //模拟一个长时间的无需同步的任务
        System.out.println("no need Synchronized task start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("no need Synchronized task end");
        
        //需要同步的任务
        System.out.println("Synchronized task start");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Synchronized task end");
    }
}

//Thread类A
public class ThreadA extends Thread {
    private Task task;
    public ThreadA(Task task) 
    {
        super();
        this.task = task;
    }
    
    public void run() 
    {
        super.run();
        task.longTimeTask();
    }
}

public class ThreadB extends Thread {
    private Task task;
    public ThreadB(Task task) 
    {
        super();
        this.task = task;
    }
    
    public void run() 
    {
        super.run();
        task.longTimeTask();
    }
}

//测试类
public class MainClass2 {

    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        
        Task task = new Task();
        Thread th1 = new ThreadA(task);
        Thread th2 = new ThreadB(task);
        
        th1.start();
        th2.start();
        
        th2.join();
        
        long totalTime = System.currentTimeMillis()-startTime;
        System.out.println("程序总计用时："+ totalTime);

    }

}

//输出结果
no need Synchronized task start
no need Synchronized task end
Synchronized task start
Synchronized task end
no need Synchronized task start
no need Synchronized task end
Synchronized task start
Synchronized task end
程序总计用时：8006毫秒

 分析上述结果可知，两个线程分别去调用加锁方法，第二个需要等到第一个执行完加锁方法中的全部步骤后才可进入执行，即使其中有一部分是无需线程同步的。

修改上述加锁部分，将Synchronized关键字只加到需要同步的代码块上：

public class Task {
    
    private int a = 0;
     public void longTimeTask() 
    {
        //模拟一个长时间的无需同步的任务
        System.out.println("no need Synchronized task start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("no need Synchronized task end");
        
        //只在需要同步的任务前加上synchronized
        synchronized(this) 
        {
            System.out.println("Synchronized task start");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Synchronized task end");
        }
    }
}

最终程序执行结果为：

//程序运行结果
no need Synchronized task start
no need Synchronized task start
no need Synchronized task end
no need Synchronized task end
Synchronized task start
Synchronized task end
Synchronized task start
Synchronized task end
程序总计用时：5010毫秒

分析上述结果可知，此时线程th1和th2访问longTimeTask方法，但是其中一部分为无需线程同步的，两个线程可以并发执行，而加上了Sychronized方法的代码块。则会在第一个线程进入时加上

task对象锁，第二个线程进入该代码块时不能获取到该锁，所以该代码块无法并行，最终使用代码块加锁的方式，在不影响程序正常执行的情况下，提高了程序并发。

　　

　　

2.实现原理：JVM 是通过进入、退出对象监视器( Monitor )来实现对方法、同步块的同步的。

具体实现是在编译之后在同步方法调用前加入一个 monitor.enter 指令，在退出方法和异常处插入 monitor.exit 的指令。

其本质就是对一个对象监视器( Monitor )进行获取，而这个获取过程具有排他性从而达到了同一时刻只能一个线程访问的目的。

而对于没有获取到锁的线程将会阻塞到方法入口处，直到获取锁的线程 monitor.exit 之后才能尝试继续获取锁。