java集合框架線程同步代碼詳解

更新時間：2017年12月22日 08:39:00 作者：光與熱

這篇文章主要介紹了java集合框架線程同步代碼詳解，具有一定借鑒價值，需要的朋友可以參考下。

List接口的大小可變數(shù)組的實現(xiàn)。實現(xiàn)了所有可選列表操作，并允許包括null在內(nèi)的所有元素。除了實現(xiàn)List接口外，此類還提供一些方法來操作內(nèi)部用來存儲列表的數(shù)組的大小。（此類大致上等同于Vector類，除了此類是不同步的。）size、isEmpty、get、set、iterator和listIterator操作都以固定時間運行。add操作以分攤的固定時間運行，也就是說，添加n個元素需要O(n)時間。其他所有操作都以線性時間運行（大體上講）。與用于LinkedList實現(xiàn)的常數(shù)因子相比，此實現(xiàn)的常數(shù)因子較低。每個ArrayList實例都有一個容量。該容量是指用來存儲列表元素的數(shù)組的大小。它總是至少等于列表的大小。隨著向ArrayList中不斷添加元素，其容量也自動增長。并未指定增長策略的細節(jié)，因為這不只是添加元素會帶來分攤固定時間開銷那樣簡單。在添加大量元素前，應用程序可以使用ensureCapacity操作來增加ArrayList實例的容量。這可以減少遞增式再分配的數(shù)量。

注意，此實現(xiàn)不是同步的。

如果多個線程同時訪問一個ArrayList實例，而其中至少一個線程從結構上修改了列表，那么它必須保持外部同步。（結構上的修改是指任何添加或刪除一個或多個元素的操作，或者顯式調(diào)整底層數(shù)組的大??；僅僅設置元素的值不是結構上的修改。）這一般通過對自然封裝該列表的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用Collections.synchronizedList方法將該列表“包裝”起來。這最好在創(chuàng)建時完成，以防止意外對列表進行不同步的訪問：

Listlist=Collections.synchronizedList(newArrayList(...));

此類的iterator和listIterator方法返回的迭代器是快速失敗的：在創(chuàng)建迭代器之后，除非通過迭代器自身的remove或add方法從結構上對列表進行修改，否則在任何時間以任何方式對列表進行修改，迭代器都會拋出ConcurrentModificationException。因此，面對并發(fā)的修改，迭代器很快就會完全失敗，而不是冒著在將來某個不確定時間發(fā)生任意不確定行為的風險。

注意，迭代器的快速失敗行為無法得到保證，因為一般來說，不可能對是否出現(xiàn)不同步并發(fā)修改做出任何硬性保證?？焖偈〉鲿M最大努力拋出ConcurrentModificationException。因此，為提高這類迭代器的正確性而編寫一個依賴于此異常的程序是錯誤的做法：迭代器的快速失敗行為應該僅用于檢測bug。

如上所示，現(xiàn)在建立一個list集合，一個線程對集合進行寫入操作，一個線程進行刪除操作

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
public class MyArrayList {
	/** 
   * 創(chuàng)建一個列表，一個線程進行寫入，一個線程讀取 iterator 和 listIterator 方法返回的迭代器是快速失敗的 
   */
	public void readWrite() {
		List<Integer> nums = new ArrayList<Integer>();
		List<Integer> synNums = Collections.synchronizedList(nums);
		//啟動寫入線程 
		new WriteListThread(synNums).start();
		//啟動刪除線程 
		new DeleteListThread(synNums).start();
	}
	public static void main(String[] args) {
		new MyArrayList().readWrite();
	}
}
class WriteListThread extends Thread {
	private List<Integer> nums;
	public WriteListThread(List<Integer> nums) {
		super(“WriteListThread”);
		this.nums = nums;
	}
	// 不停寫入元素1 
	public void run() {
		while (true) {
			nums.add(new Random().nextint(1000));
			System.out.println(Thread.currentThread().getName());
		}
	}
}
class DeleteListThread extends Thread {
	private List<Integer> nums;
	public DeleteListThread(List<Integer> nums) {
		super(“DeleteListThread”);
		this.nums = nums;
	}
	// 刪除第一個元素 
	public void run() {
		while (true) {
			try{
				System.out.println(Thread.currentThread().getName()+”:”+nums.remove(0));
			}
			catch(Exception e){
				continue ;
			}
		}
	}
}

通過List<Integer>synNums=Collections.synchronizedList(nums);就能對原子操作進行同步了，但是官方api示例為什么要自己手動添加同步呢？

List list = Collections.synchronizedList(new ArrayList()); 
 synchronized(list) { 
   Iterator i = list.iterator(); // Must be in synchronized block 
   while (i.hasNext()) 
     foo(i.next()); 
 }

查看Collections.synchronizedList的源代碼

SynchronizedCollection(Collection<E> c) { 
      if (c==null) 
        throw new NullPointerException(); 
    this.c = c; 
      mutex = this; 
    }

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
public class MyArrayList {
	/** 
   * 創(chuàng)建一個列表，一個線程進行寫入，一個線程讀取 iterator 和 listIterator 方法返回的迭代器是快速失敗的 
   */
	public void readWrite() {
		List<Integer> nums = new ArrayList<Integer>();
		List<Integer> synNums = Collections.synchronizedList(nums);
		//啟動寫入線程 
		new WriteListThread(synNums).start();
		//啟動刪除線程 
		new DeleteListThread(synNums).start();
	}
	public static void main(String[] args) {
		new MyArrayList().readWrite();
	}
}
class WriteListThread extends Thread {
	private List<Integer> nums;
	public WriteListThread(List<Integer> nums) {
		super("WriteListThread");
		this.nums = nums;
	}
	// 不停寫入元素1 
	public void run() {
		while (true) {
			nums.add(new Random().nextint(1000));
			System.out.println(Thread.currentThread().getName());
		}
	}
}
class DeleteListThread extends Thread {
	private List<Integer> nums;
	public DeleteListThread(List<Integer> nums) {
		super("DeleteListThread");
		this.nums = nums;
	}
	// 刪除第一個元素 
	public void run() {
		while (true) {
			try{
				System.out.println(Thread.currentThread().getName()+":"+nums.remove(0));
			}
			catch(Exception e){
				continue ;
			}
		}
	}
}

可見對于集合同步操作，使用Collections的同步包裝工具類，還需要對非原子操作用戶還需要手動進行同步

如下所示，加一個線程，對集合進行讀取

class ReadListThread extends Thread {
	private List<Integer> nums;
	public ReadListThread(List<Integer> nums) {
		super(“ReadListThread”);
		this.nums = nums;
	}
	// 不停讀取元素,非原子操作，則需要手動加上鎖 
	public void run() {
		while (true) {
			//休眠，將鎖交給其他線程 
			try {
				Thread.sleep(1000);
			}
			catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			synchronized (nums) {
				if (nums.size() > 100) {
					Iterator<Integer> iter = nums.iterator();
					while (iter.hasNext()) {
						System.out.println(Thread.currentThread().getName() 
						                + ”:” + iter.next());
						;
					}
				} else{
					try {
						nums.wait(1000);
					}
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

總結

以上就是本文關于java集合框架線程同步代碼詳解的全部內(nèi)容，希望對大家有所幫助。感興趣的朋友可以繼續(xù)參閱本站其他相關專題，如有不足之處，歡迎留言指出。感謝朋友們對本站的支持！

您可能感興趣的文章: