java线程的互斥

    多线程程序中的各个线程都是自由运行的，所以它们有时就会同时操作同一个实例。这在某些情况下会引发问题。例如，从银行账户取款时，余额确认部分的代码应该是像下面这样的。

　　if (可用余额大于取款金额) {

　　　　从可用余额中减掉取款金额

　　}　　

 首先确认可用余额，确认是否允许取款。如果允许，则从可用余额上减掉取款金额。这样才不会导致可用余额变为负数。但是，如果两个线程同时执行这段代码，那么可用余额就有可能会变为负数。假设可用余额＝1000元，取款金额＝ 1000元，那么这种情况就如下图所：

我们可以通过使用synchronized关键字完成线程的同步，能够解决部分线程安全问题在java中synchronized同步关键字可以使用在静态方法和实例方法中使用，两者的区别在于锁的不同 ：对象锁与类锁（）（锁可以理解为使需要互斥执行的代码块被一个标识保护，当一个线程执行此代码块时，其他线程只能等待）
对象锁

当一个对象中有synchronized method或synchronized block的时候调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。

如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放

示例代码：

public class TraditionThread {

	public static void main(String[] args) {
		new TraditionThread().init();

	}

	private void init() {
		final Outpurer outpurer = new Outpurer();
		new Thread(new Runnable() {

			@Override
			public void run() {

				while (true) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outpurer.output("yucaixiang");

				}
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outpurer.output("linshanshan");

				}

			}
		}).start();

	}

	static class Outpurer {

		public void output(String name) {
			int len = name.length();
			//此处为对象锁，当outputer对象被调用时即锁住以下代码块
			synchronized (this) {
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		

	}
}

此代码会不断输出两个名字，如果不用synchronized关键字，输出的两个名字会可能出现错误。

synchronized关键字也可以放到方法上，锁住的时实例化的对象，如果时静态方法，则需要类锁。

public synchronized void output2(String name) {
			int len = name.length();

			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}

 

类锁

由上述同步静态方法引申出一个概念，那就是类锁。其实系统中并不存在什么类锁。当一个同步静态方法被调用时，系统获取其实就是代表该类的类对象的对象锁，在程序中获取类锁可以尝试用以下方式获取类锁。类锁也可以理解为锁住的是字节码对象。
synchronized (xxx.class) {...}
synchronized (Class.forName("xxx")) {...}

示例代码：

public class TraditionThread {

	public static void main(String[] args) {
		new TraditionThread().init();

	}

	private void init() {
		final Outpurer outpurer = new Outpurer();
		new Thread(new Runnable() {

			@Override
			public void run() {

				while (true) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outpurer.output("yucaixiang");

				}
			}
		}).start();

		new Thread(new Runnable() {

			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					outpurer.output2("linshanshan");

				}

			}
		}).start();

	}

	static class Outpurer {

		public void output(String name) {
			int len = name.length();
			synchronized (Outpurer.class) {
				for (int i = 0; i < len; i++) {
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}

		public static synchronized void output2(String name) {
			int len = name.length();
			for (int i = 0; i < len; i++) {
				System.out.print(name.charAt(i));
			}
			System.out.println();

		}

	}
}

此代码synchronized关键字锁住的是字节码对象。

不论是同步代码块还是同步方法（包括静态同步方法），只要他们使用的锁是同一个对象就可以实现互斥，即同步

同时获取2类锁
         同时获取类锁和对象锁是允许的，并不会产生任何问题，但使用类锁时一定要注意，一旦产生类锁的嵌套获取的话，就会产生死锁，因为每个class在内存中都只能生成一个Class实例对象。

同步静态方法/静态变量互斥体
          由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只由一份。所以，一旦一个静态的方法被申明为synchronized。此类所有的实例化对象在调用此方法，共用同一把锁，我们称之为类锁。一旦一个静态变量被作为synchronized block的mutex。进入此同步区域时，都要先获得此静态变量的对象锁

           synchronized的缺陷：

           当某个线程进入同步方法获得对象锁，那么其他线程访问这里对象的同步方法时，

必须等待或者阻塞，这对高并发的系统是致命的，这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环，

那么它就永远不会释放这个对象锁，那么其他线程就要永远的等待。这是一个致命的问题。