synchronized关键字

synchronized的应用方式

1. 修饰实例方法，对于普通同步方法，锁是当前实例对象。
2. 修饰静态方法，对于静态同步方法，锁是当前类的Class对象。
3. 修饰代码块，对于同步方法块，锁是Synchonized括号里配置的对象

synchronized可以修饰代码块、修饰方法。修饰代码块的锁是任意的对象，但是要保证多个线程的锁是同一把；修饰方法直接加在方法声明上即可。

出现线程安全的原因：处于多线程的环境下、有共享资源、有多条语句操作了共享资源。总而言之就是多个线程操作了共享资源。

synchronized修饰静态方法

package com.myvolatile;

public class Synchronized1 implements Runnable {

	static int i = 0;

	//加static	
	public static synchronized void increase() {
		i++;
	}

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

	public static void main(String[] args) throws InterruptedException {
		// new新实例
		Thread t1 = new Thread(new Synchronized1());
		// new新实例
		Thread t2 = new Thread(new Synchronized1());
		t1.start();
		t2.start();
		// join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
		t1.join();
		t2.join();
		System.out.println(i);
	}

}

如果increase（）方法不加static修饰，那么运行结果绝大部分情况不会是2000000，因为存在线程安全问题。同时，因为synchronized修饰的是静态方法，锁对象是当前类，只有一把，所以，尽管在main方法中用了两个不同的实例对象，加了synchronized同步之后，同样能保证线程安全。

synchronized修饰普通方法

package com.myvolatile;

public class Synchronized2 implements Runnable {

	static int i = 0;

	// 加static
	public synchronized void increase() {
		i++;
	}

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

	public static void main(String[] args) throws InterruptedException {
		Synchronized2 synchronized2 = new Synchronized2();
		Thread t1 = new Thread(synchronized2);
		Thread t2 = new Thread(synchronized2);
		t1.start();
		t2.start();
		// join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
		t1.join();
		t2.join();
		System.out.println(i);
	}

}

上面这段代码，运行结果同样是2000000。因为main方法中用的是同一个实例对象，两个线程的锁是同一把，所以t1执行increase方法时，t2只能是阻塞状态；反之也一样，此种情况可以保证线程安全。

synchronized的可重入性

package com.myvolatile;

/**
 * synchronized的可重入性
 * 
 * @author Administrator
 *
 */
public class Synchronized3 implements Runnable {

	static int i = 0;

	// 加static
	public synchronized void increase() {
		i++;
	}

	@Override
	public void run() {
		for (int j = 0; j < 1000000; j++) {
			synchronized (this) {
				i++;
			}
			increase();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Synchronized3 synchronized2 = new Synchronized3();
		Thread t1 = new Thread(synchronized2);
		Thread t2 = new Thread(synchronized2);
		t1.start();
		t2.start();
		// join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
		t1.join();
		t2.join();
		System.out.println(i);
	}

}

从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，因为锁只有一把；但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功，在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。需要特别注意另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。

由于synchronized的可重入性，上述代码的运行结果是4000000。