Java多线程编程基础篇（二）-多线程同步关键字

一、多线程同步关键字-synchronized

1.概念

    synchronized保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。当多个并发线程访问同一个对象object中的同步代码块时，一个时间内只有一个线程能够得到执行，另一个线程必须等到当前线程执行完这个代码块之后才能执行，但是其他的线程仍然能够访问该object中的非synchronized同步代码块。

2.使用方法

    java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

• 修饰实例方法：锁是当前实例对象
• 修饰静态方法：锁是当前类的class对象
• 修饰代码块：锁是括号里的对象

（1）修饰实例方法

    当synchronized作用于实例方法时，所示其实例对象。

    在下面的例子中定义了一个静态变量num，定义了一个incr()方法对num进行+1的操作，在run方法中是循环调用incr方法5次。最后在main方法中是创建了两个线程对num进行操作。在该方法中synchronized修饰的是实例方法incr，此时线程的锁便是实例对象instance。

    一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他的线程就无法获取该对象的锁，但是其他的对象还是可以访问该实例对象的其他非synchronized方法。

public class Test1 implements Runnable{
	
	public static int num = 0;
	
	public synchronized void incr() {
		num++;
		System.out.println("Thread-Id:"+Thread.currentThread().getId()+" num="+num);
	}
	
	@Override
	public void run() {
	    for(int i = 0; i< 5; i++) {
	    	incr();
	    }
	}
	
	public static void main(String[] args) throws InterruptedException {
		Test1 test1 = new Test1();
		Thread t1 = new Thread(test1);
		Thread t2 = new Thread(test1);
		
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println("num="+num);   /**num=10*/
		
	}
}

    

在上面的例子中是两个线程共同操作一个对象，在下面的例子中可以看到两个线程操作的是不同的对象，这时候不同的对象有不同的锁，所以都会获取到各自的锁，这时候获取到的结果就不一定是10了，也许是比10小的数。这种情况下是不满足线程安全的。

public class Test1 implements Runnable{
	public static int num = 0;
	public synchronized void incr() {
		num++;
		System.out.println("Thread-Id:"+Thread.currentThread().getId()+" num="+num);
	}
	@Override
	public void run() {
	    for(int i = 0; i< 5; i++) {
	    	incr();
	    }
	}
	
	public static void main(String[] args) throws InterruptedException {
		Test1 test1 = new Test1();
		Test1 test2 = new Test1();
		Thread t1 = new Thread(test1);
		Thread t2 = new Thread(test2);
		
		t1.start();
		t2.start();
		//t1.join();
		//t2.join();
		//System.out.println("num="+num);   /**num=10？？*/
		
	}
}

 （2）修饰静态方法

当synchronized作用与静态方法时，锁是当前类的class对象。

    由于静态方法是类成员，因此通过class对象锁可以控制静态成员的并发操作。如果一个线程A调用一个实例对象的非静态同步方法，线程B调用这个实例对象所属的类的静态同步方法，他们之间是不存在互斥的，因此两个线程占用的锁是不一样的。但是如果两个方法共同操作同一个静态变量num，那么还是需要考虑线程安全的问题。

public class Test1 implements Runnable{
	
	public static int num = 0;
	
	/**
	 * 非静态同步方法，占用的锁是当前实例对象的锁
	 */
	public synchronized void incr1() {
		num++;
	}
	
	/**
	 * 静态同步方法，占用的锁是当前类的锁
	 */
	public static synchronized void incr() {
		num++;
		System.out.println("Thread-Id:"+Thread.currentThread().getId()+" num="+num);
	}
	
	@Override
	public void run() {
	    for(int i = 0; i< 5; i++) {
	    	incr();
	    }
	}
	
	public static void main(String[] args) throws InterruptedException {
		Test1 test1 = new Test1();
		Test1 test2 = new Test1();
		Thread t1 = new Thread(test1);
		Thread t2 = new Thread(test2);
		
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println("num="+num);   /**num=10*/
	}
}

3.修饰静态块

    从下面的例子中可以看出，是将synchronized作用于一个给定的实例对象instance，当前实例对象就是锁对象，每次线程进入synchronized的代码块时就要求当前线程必须拿到instance实例的对象所，其他的线程就必须等待。

public class Test1 implements Runnable{
	
	public static int num = 0;
	
	static Test1 instance = new Test1();
	
	@Override
	public void run() {
	    synchronized(instance) {
	    	for(int i = 0; i< 5; i++) {
	    		num++;
	    		System.out.println("Thread-Id:"+Thread.currentThread().getId()+" num="+num);
	    	}
	    }
	}
	
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(instance);
		Thread t2 = new Thread(instance);
		
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println("num="+num);   /**num=10*/
		
	}
}

二、多线程同步关键字-volatile

1.概念

    volatile是一个类型修饰符，他主要用于修饰被不同的线程访问和修改的变量，他是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。

    可以确保将变量的更新操作通知到其他的线程，当把变量声明为volatile类型，编译与运行时都会注意到这个变量是共享的，因此该变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

    在访问volatile变量时不会执行加锁操作，因此也就不会执行线程阻塞，他是一种比synchronized关键字更轻量级的同步机制。

2.volatile使用方法

class volatileTest implements Runnable {  
	  
    private volatile boolean flag = false;  
  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            try {
            	System.out.println("Thread-name:"+Thread.currentThread().getName()+" i:"+i+" flag="+flag);
            	//线程名为test1，则将flag值改为true，同时打印出新旧flag值
            	if("test1".equals(Thread.currentThread().getName())) {
            		boolean oldflag = flag;
            		flag = true;
            		System.out.println("test1 oldflag="+oldflag+" flag="+flag);
            	}else if("test2".equals(Thread.currentThread().getName())) {
            		//如果线程名为test2，则将flag值修改为false，同时打印出新旧flag值
            		boolean oldflag = flag;
            		flag = false;
            		System.out.println("test2 oldflag="+oldflag+" flag="+flag);
            	}
            	Thread.sleep(5000);
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
}  
  
public class Test {  
   
    public static void main(String[] args) {  
  
    	volatileTest test = new volatileTest();  
  
        Thread t1 = new Thread(test, "test1");  
        Thread t2 = new Thread(test, "test2");  
  
        t1.start();  
        t2.start();  
  
    }  
}  

在上面的例子中可以看到，当两个线程同时操作volatile修饰的变量flag时，两个线程每次拿到的都是flag的最新的值，但是这个时候对于获取到flag的值两个线程并没有一个互斥的操作，并不能保证操作的原子性。

3.volatile的特性

（1）volatile的可见性：当多个线程访问同一个变量时，一个线程修改了这个变量，其他得线程能够立即看的到值得改变，这一个特性对于volatile是满足的。

（2）volatile的原子性：不满足，对于下面的例子，正常期望的结果应该是每次运行都能得到值为10000，但是在实际的运行结果中发现每次得到的结果都不一样，因此volatile虽然保证了可见性，确保每次拿到的值都是最新的，但是不能确保操作的原子性。

public class Test {
    public volatile int inc = 0;
     
    public void increase() {
        inc++;
    }
     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
         
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

三、synchronized与volatile的总结

1.synchronized关键字一次只允许一个线程持有某个特定的锁，因此可以使用该特性实现对共享数据的访问，一次只有一个线程能够使用该共享数据。

2.volatile主要是使变量的值在发生改变时能尽快的让其他的线程知道，使线程获取到数据是最新的。

3.volatile本质是告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他的线程被阻塞住。

4.volatile仅能够用在变量级别，synchronized则可以使用在变量和方法中。

5.volatile仅能够实现变量修改的可见性，而synchronized可以保证变量修改的可见性和原子性。

6.volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。