Java并发编程实践笔记（一）

先如下代码：

public class ListHelper<Integer> {
    public List<Integer> list = Collections
            .synchronizedList(new ArrayList<Integer>());

    // private List<E> list = Collections.synchronizedList(new ArrayList<E>());
    public synchronized boolean put(Integer i) {

        list.add(i);
        System.out.println(Thread.currentThread().getName() + " --- " + i);
        return true;
    }
}

代码说明1）变量list用Collections.synchronizedList的作用是把本身不是线程安全的容器ArrayList变成线程安全的

                2）ListHepler的方法都用了synchronized来进行加锁，用来同步。

                3)注意list变量的访问权限是public！

现在提供两个线程类来提供模拟这个同步：

线程A和线程B的代码如下（两个代码除了类名字完全一样，所以在此仅贴出来A的)

public class A extends Thread {
    private ListHelper<Integer> lh;

    public A(ListHelper<Integer> lh) {
        super("A");
        this.lh = lh;
    }

    public void run() {
        synchronized (lh) {
            for (int i = 0; i < 9; i++) {
                lh.put(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}

客户端的代码：

public class Client {
  public static void main(String args[]) throws InterruptedException{
	  ListHelper<Integer> lh = new ListHelper<Integer>();
	  A a = new A(lh);
	  B b = new B(lh);	
	  a.start();	
	  b.start();
  }
}

运行结果如下：
A --- 0
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

从运行结果来看，一切都是那么顺利，当线程A执行的时候，B阻塞；然后A执行完毕释放锁，B获取锁并运行。看起来很安全的样子。

但是下面在提供一个thread C:

public class C extends Thread {
   private ListHelper<Integer> lh;
   public C(ListHelper<Integer> lh){
	  super("C");
	  this.lh = lh;  
   }
   
  

public void run() {
		synchronized (lh.list) {//添加了list锁
			for (int i = 0; i < 9; i++) {
				System.out.println(Thread.currentThread().getName() + "------" + i);
				lh.list.add(i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}
		
	}

}

修改客户端代码如下：

  public static void main(String args[]) throws InterruptedException{
	  ListHelper<Integer> lh = new ListHelper<Integer>();
	  A a = new A(lh);
	  B b = new B(lh);	
	  C c = new C(lh);
	  a.start();	
	  b.start();
	  c.start();
  }

运行结果如下：

A --- 0
C------0
C------1
C------2
C------3
C------4
C------5
C------6
C------7
C------8
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

发现线程A在执行的时候，由于A获取了ListHelper的锁，导致B线程的阻塞，当线程A在执行完的时候释放锁，然后B获取锁得到执行。但是有如下问题出现了

1）变量list不是被Collectoion.synchronizedList加过锁了么？

2）在A获取锁并执行的时候C怎么可以执行呢？

3)并且A只执行了一次put方法之后等着C执行完毕后才得到运行呢？

解答：

   A获取的是ListHelper对象锁，而Collection.synchronizedList为list添加的锁是另外一个锁，也就是说两个锁不是一回事儿。所以问题3就可以迎刃而解了：

 1）A执行一次put方法，释放了list锁。此时A仍然拥有ListHelper锁，B在等待获取ListHelper锁，所以B仍然阻塞

2）C获取到了list锁执行完for循环并释放list锁，A得到list锁并运行完for循环，释放ListHelper锁。

3）B得到ListHelper锁，并运行完毕,程序退出

所以A线程获取ListHelper对象锁执行的并执行的时候是没法阻塞C线程的执行的，除非A线程也获取了list上的锁！！！

所以可以把A和B的run方法代码改成：

public void run() {
		synchronized (lh) {
			synchronized (lh.list) {//添加了list锁
				for (int i = 0; i < 9; i++) {
					lh.put(i);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			
		}

	}

再次运行获得结果：

A --- 0
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
C------0
C------1
C------2
C------3
C------4
C------5
C------6
C------7
C------8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

当然要把ListHelper设置成线程安全的类，最简单的是不发布list变量，可以把list的改成private同时不提供getList()方法，不过这样的话Collection.synchronizedList就失去了它的作用。怎么在public访问权限不变的情况下，只利用Collection.synchronizedList提供的锁来控制线程同步的呢？上面的代码A和B明显用到了两个锁，一个是ListHelper锁，另一个是Collection.synchronizedList提供的锁，其实完全可以利用后者而不用ListHelper锁来完成上述的更能。

修改ListHelper代码如下：

public class ListHelper<Integer> {
	public List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());

	// private List<E> list = Collections.synchronizedList(new ArrayList<E>());
	public  boolean put(Integer i) {
		synchronized(list){//在list上加锁
			list.add(i);
			System.out.println(Thread.currentThread().getName() + " --- " + i);
			return true;
		}
		
	}
}

这样的话上面的A和B的run方法就可以去掉synchronized (lh) 而只用synchronized (lh.list) 使得程序安全并发的运行了

public void run() {
		//synchronized (lh) {
			synchronized (lh.list) {
				for (int i = 0; i < 9; i++) {
					lh.putIfAbsent(i);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			
		}

	//}
}