synchronized 关键字

        线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

 

synchronized关键字最主要有以下3种应用方式

1.修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

/**
 * synchronized关键字学习
 * @author zhangfan
 *
 */
public class Accounting implements Runnable {

	static int i = 0;

	/**
	 * synchronized 修饰实例方法
	 */
	public synchronized void increase() {
		i++;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10000; i++) {
			increase();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		 //多个线程访问一个实例对象的synchronized非静态方法时线程安全
		Accounting accounting = new Accounting();
		Thread t1 = new Thread(accounting);
		Thread t2 = new Thread(accounting);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}
	/**
     * 输出结果:20000
     */
}

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test.synchronizedtest;

/**
 * synchronized关键字学习
 * @author zhangfan
 *
 */
public class Accounting implements Runnable {

	static int i = 0;

	/**
	 * synchronized 修饰实例方法
	 */
	public synchronized void increase() {
		i++;
	}

	@Override
	public void run() {
		for (int i = 0; i < 10000; i++) {
			increase();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Accounting accounting1 = new Accounting();
		Accounting accounting2 = new Accounting();
		Thread t1 = new Thread(accounting1);
		Thread t2 = new Thread(accounting2);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}
	/**
     * 输出结果:19838
     * t1和t2线程是两个对象，使用的是不同的锁，因此线程安全是无法保证的。
     * 解决这种问题可以让synchronized作用于静态方法，这样对象锁就当前类对象，由于无论创建多少个实例对象，
     * 但对于的类对象拥有只有一个，所有在这样的情况下对象锁就是唯一的
     */
}

 

2.修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test.synchronizedtest;

/**
 * synchronized关键字学习
 * @author zhangfan
 *
 */
public class Accounting implements Runnable {

	static int i = 0;

	/**
	 * synchronized 修饰静态实例方法,锁的是类对象，而非实例对象
	 */
	public static synchronized void increase() {
		i++;
	}
	
	/**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase4Obj(){
        i++;
    }

	@Override
	public void run() {
		for (int i = 0; i < 10000; i++) {
			increase();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Accounting accounting1 = new Accounting();
		Accounting accounting2 = new Accounting();
		Thread t1 = new Thread(accounting1);
		Thread t2 = new Thread(accounting2);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}
	/**
     * 输出结果:20000
     * synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。
     * 注意代码中的increase4Obj方法是实例方法，其对象锁是当前实例对象，
     * 如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。
     */
}

3.修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

package com.travelzen.finance.checkcenter.ticket.uploadmanager.test.synchronizedtest;

/**
 * synchronized关键字学习
 * @author zhangfan
 *
 */
public class Accounting implements Runnable {
	
	static int i = 0;

	@Override
	public void run() {
		synchronized(Accounting.class){
			for (int j = 0; j < 1000000; j++) {
				i++;
			}
		}
	}
	/*
	@Override
	public void run() {
		synchronized(this){
			for (int j = 0; j < 1000000; j++) {
				i++;
			}
		}
	}
	 */
	public static void main(String[] args) throws InterruptedException {
		Accounting accounting1 = new Accounting();
		Accounting accounting2 = new Accounting();
		Thread t1 = new Thread(accounting1);
		Thread t2 = new Thread(accounting2);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}
	/** 
	 * this-对象锁
     * 输出结果:1425727
     *
     * Accounting.class 类锁
     * 输出结果：2000000
     */
}