java线程之synchronized关键字

       synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。

　　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：

　　public synchronized void accessVal(int newVal);

　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。

　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。

　　2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

　　 synchronized(syncObject) {

　　//允许访问控制的代码

　　}

　　synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

　　对 synchronized(this)的一些理解

　　一、当两个并发线程访问同一个对象object中的这个 synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

　　二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该 object中的非synchronized(this)同步代码块。

　　三、尤其关键的是，当一个线程访问object的一个 synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

　　四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

java中每个对象都有一个隐式的锁，如果一个方法由synchronized关键字声明，那些对象的锁将保护整个方法。

也就是说，要调用这个方法，线程必须先获得对象的锁。

隐式对象锁只有一个关联条件。wait方法把线程加到等待集中，notify/notifyAll方法解除等待线程的阻塞状态。

也两个方法等价于Condition（条件变量）的await,signal/signalAll方法。

隐式的锁和条件存在一些缺点。如下：

1.不能中断一个正在试图获得锁的线程。

2.试图获得锁时不能设定超时。

3.每个锁只有一个条件有时候显得不够用。

4.虚拟机的加锁原语不能很好地映射到硬件可用的最有效的加锁机制上。

 

在下面三个条件下，对一个域的并行访问是安全的：

1.域是volatile的。

2.域是final的，并且在构造器调用完成后被访问。

3.对域的访问有锁保护。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒(notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程b要进入account的就绪队列，等到得到锁后才可以执行。

一个线程执行临界区代码过程如下：

1 获得同步锁

2 清空工作内存

3 从主存拷贝变量副本到工作内存

4 对这些变量计算

5 将变量从工作内存写回到主存

6 释放锁

可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

生产者/消费者模式 

        生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，往往多个线程之间都是有协作的。

        假设有这样一种情况，有一个桌子，桌子上面有一个盘子，盘子里只能放一颗鸡蛋，A专门往盘子里放鸡蛋，如果盘子里有鸡蛋，则一直等到盘子里没鸡蛋，B专门从盘子里拿鸡蛋，如果盘子里没鸡蛋，则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区，每次往盘子放鸡蛋应该都是互斥的，A的等待其实就是主动放弃锁，B等待时还要提醒A放鸡蛋。

如何让线程主动释放锁

很简单，调用锁的wait()方法就好。wait方法是从Object来的，所以任意对象都有这个方法。看这个代码片段：

package com.sample.synctest;

import java.util.ArrayList;
import java.util.List;

public class Plate {

	List<Object> eggs = new ArrayList<Object>();

	public synchronized Object getEgg() {
		if (eggs.size() == 0) {
			try {
				wait();
			} catch (InterruptedException e) {

			}
		}
		Object egg = eggs.get(0);
		eggs.clear(); // 清空盘子
		notify(); // 唤醒阻塞队列的某些线程到就绪队列
		System.out.println(Thread.currentThread().getName() + ":取鸡蛋");
		return egg;
	}
	
	public synchronized void putEgg(Object egg) {
		if (eggs.size() > 0) {
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		eggs.add(egg);	//往盘子里面放鸡蛋
		notify();		//唤醒阻塞对列的某些线程到就绪队列
		System.out.println(Thread.currentThread().getName() + ":放鸡蛋");
	}
} 

 

public class AddThread implements Runnable {
	private Plate plate;
	private Object egg = new Object();
	public AddThread(Plate plate) {
		this.plate = plate;
	}
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			plate.putEgg(egg);
		}
	}

}

public class GetThread implements Runnable {
	private Plate plate;

	public GetThread(Plate plate) {
		this.plate = plate;
	}

	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			plate.getEgg();
		}
	}

}

   

public class Client{
	public static void main(String[] args) {
		try {
			Plate plate = new Plate();
			Thread t1 = new Thread(new AddThread(plate), "Thread-Add");
			Thread t2 = new Thread(new GetThread(plate), "Thread-Get");
			t1.start();
			t2.start();
			t1.join();
			t2.join();
		} catch (Exception e) {
		}
	}

}


Thread-Add:放鸡蛋
Thread-Get:取鸡蛋
Thread-Add:放鸡蛋
Thread-Get:取鸡蛋
Thread-Add:放鸡蛋
Thread-Get:取鸡蛋
Thread-Add:放鸡蛋
Thread-Get:取鸡蛋
Thread-Add:放鸡蛋
Thread-Get:取鸡蛋

 

声明一个Plate对象为plate，被线程A和线程B共享，A专门放鸡蛋，B专门拿鸡蛋。假设
1 开始，A调用plate.putEgg方法，此时eggs.size()为0，因此顺利将鸡蛋放到盘子，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法，此时eggs.size()不为0，调用wait()方法，自己进入了锁对象的阻塞队列。
3 此时，来了一个B线程对象，调用plate.getEgg方法，eggs.size()不为0，顺利的拿到了一个鸡蛋，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列有一个A线程对象，唤醒后，它进入到就绪队列，就绪队列也就它一个，因此马上得到锁，开始往盘子里放鸡蛋，此时盘子是空的，因此放鸡蛋成功。
4 假设接着来了线程A，就重复2；假设来料线程B，就重复3。 
整个过程都保证了放鸡蛋，拿鸡蛋，放鸡蛋，拿鸡蛋。