java線程安全測試

1. java線程安全性問題

//下次發源代碼時先整理好再發出來,累死了~呼呼
packaget;

importjava.io.File;
importjava.io.IOException;
importjava.util.Iterator;
importjava.util.List;

importjavax.servlet.ServletConfig;
importjavax.servlet.ServletContext;
importjavax.servlet.ServletException;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;

/**
*先幫你整理下,你這樣估計沒幾人願意看:
*
*@authorHuangYong
*
*/
{

	//驗證版本是否一致的java身份證
	=-5318854875823790516L;

	//上傳的組件中要運用到的對象
	privateServletContextsc;

	//保存路徑
	privateStringsavePath;

	publicvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)
			throwsServletException,IOException{

		doPost(request,response);

	}

	publicvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)
			throwsServletException,IOException{

		//解決中文亂碼問題，後面可以看看過濾器
		request.setCharacterEncoding("UTF-8");

		//設計模式中的工廠模式
		DiskFileItemFactoryfactory=newDiskFileItemFactory();

		//用來在Servlet中完成文件
		ServletFileUploapload=newServletFileUpload(factory);
		try{
			Listitems=upload.parseRequest(request);
			Iteratorit=items.iterator();
			while(it.hasNext()){

				//包括傳過來的所有信息，包括文件和普通文本信息
				FileItemitem=(FileItem)it.next();

				//這個方法判斷信息類型，普通文本為true文件為false
				if(item.isFormField()){
					System.out.println("上傳的表單項的名稱:"+item.getFieldName());
					System.out.println("內容:"+item.getString("UTF-8"));
				}else{
					if(item.getName()!=null&&!item.getName().equals("")){
						System.out.println("上傳文件的文件大小："+item.getSize());
						System.out
								.println("上傳文件的文件類型："+item.getContentType());
						System.out.println("上傳文件的文件名字："+item.getName());

						Filetempfile=newFile(item.getName());

						//sc.getRealPath("/")代表獲得當前應用的物理路徑
						//,savePath為上傳文件保存在伺服器上的地址，自己在web.xml下設好的
						Filefile=newFile(sc.getRealPath("/")+savePath
								+tempfile.getName());
						//將上傳的文件保存在伺服器的物理磁碟目錄下
						item.write(file);
						//在jsp頁面上現實上傳的結果
					}
				}
			}
			//解析文件
		}catch(Exceptione){
			thrownewRuntimeException(e);
		}

	}

	publicvoidinit(ServletConfigconfig)throwsServletException{
		//這是自己設的參數，用於保存上傳文件應當保存的目錄地址，在xml文件中初始化
		savePath=config.getInitParameter("savePath");
		sc=config.getServletContext();
	}
}

1. 首先, 成員變數用private修飾就是為了不讓外部程序隨意訪問, 如果需要暴露給外部使用時, 通常需要getter訪問器來控制許可權, 框架程序除外;

2. 關於成員變數引起的線程安全問題根據需求來控制, 如果沒有必要時直接定義在方法體內就沒有線程安全問題了, 象JDBC的對象(Connection, PreparedStatement, ResultSet..)直接在方法體內部定義;

3. sc 和 savePath 正常情況下沒有線程安全問題, 不過你存儲上傳的文件時要小心同名文件問題

希望能幫助你

2. 如何確保Java線程安全

java中，線抄程安全的解決方法或過程：
1.如果對象是immutable，則是線程安全的，例如:String，可以放心使用。
2. 如果對象是線程安全的，則放心使用。
3.有條件線程安全，對於Vector和Hashtable一般情況下是線程安全的，但是對於某些特殊情況，需要通過額外的synchronized保證線程安全。
4.使用synchronized關鍵字。

3. Java Swing開發中的線程安全

SwingAPI的設計目標是強大 靈活和易用 非凡地 我們希望能讓程序員們方便地建立新的Swing組件 不論是從頭開始還是通過擴展我們所提供的一些組件 出於這個目的 我們不要求Swing組件支持多線程訪問 相反 我們向組件發送請求並在單一慎李線程中執行請求 本文討論線程和Swing組件 目的不僅是為了幫助你以線程安全的方式使用SwingAPI 而且解釋了我們為什麼會選擇現在這樣的線程方案 本文包括以下內容

單線程規則 Swing線程在同一時刻僅能被一個線程所訪問 一般來說 這個線程是事件派發線程 規則的例外 有些操作保證是線程安全的 事件分發 假如你需要從事件處理或繪制代碼以外的地方訪問UI 那麼你可以使用SwingUtilities類的invokeLater要求在事件派發線程中執行某些代碼 這個方法會立即返回 不會等待代碼執行完畢 invokeAndWait行為與invokeLater類似 除了這個方法會等待代碼執行完畢 一般地 你可以用invokeLater來代替這個方法 下面是一些使用這幾個API的例子 請同時參閱《TheJavaTutorial》中的 BINGOexample 尤其是以下幾個類 CardWindow ControlPane Player和OverallStatusPane

使用invokeLater方法你可以從任何線程調用invokeLater方法以請求事件派發線程運行特定代碼 你必須把要運行的代碼放到一個Runnable對象的run方法中 並將此Runnable對象設為invokeLater的參數 invokeLater方法會立即返回 不等待事件派發線程執行指定代碼 這是一個使用invokeLater方法的例子

RunnabledoWorkRunnable=newRunnable };

SwingUtilities invokeLater;使用invokeAndWait方法invokeAndWait方法和invokeLater方法很相似 除了invokeAndWait方法會等事件派發線程執行了指定代碼才返回 在可能的情況下 你應該盡量用invokeLater來代替invokeAndWait 假如你真的要使用invokeAndWait 請確保調用invokeAndWait的線程不會在調用期間持有任何其他線程可能需要的鎖

這是一個使用invokeAndWait的例子

}; 褲滑SwingUtilities invokeAndWait; }

類似地 假設一個線程需要對GUI的狀態進行存取 比如文本域的內容 它的代碼可能類似這樣

voidprintTextField throwsException }; SwingUtilities invokeAndWait; System out println;}

假如你能避免使用線程 最好這樣做 線程可能難於使用 並使得程序的debug更困難 一般來說 對於嚴格意義下的GUI工作 線程是不必要的 比如對組件屬性的更新 不管怎麼說 有時候線程是必要的 下列情況是使用線程的一些典型情況 執行一項費時的任務而不必將事件派發線程鎖定 例子包括執行大量計算的情況 會導致大量類被裝載的情況 和為網路或磁碟I/O而阻塞的情況 重復地執行一項操作 通常在兩次操作間間隔一個預定的時間周期 要等待來自客戶的消息 你可以使用兩個類來幫助你實現線程 SwingWorker 創建一個後台線程來執行費時的操作 Timer 創建一個線程來執行或多次執行某些代碼 在兩次執行間間隔用戶定義的延遲 使用SwingWorker類SwingWorker類在SwingWorker java中實現 這個類並不包寬純遲含在Java的任何發行版中 所以你必須單獨下載它 SwingWorker類做了所有實現一個後台線程所需的骯臟工作 雖然許多程序都不需要後台線程 後台線程在執行費時的操作時仍然是很有用的 它能提高程序的性能觀感

要使用SwingWorker類 你首先要實現它的一個子類 在子類中 你必須實現construct方法還包含你的長時間操作 當你實例化SwingWorker的子類時 SwingWorker創建一個線程但並不啟動它 你要調用你的SwingWorker對象的start方法來啟動線程 然後start方法會調用你的construct方法 當你需要construct方法返回的對象時 可以調用SwingWorker類的get方法 這是一個使用SwingWorker類的例子

//在main方法中 finalSwingWorkerworker=newSwingWorker }; worker start; //在動作事件處理方法中 JOptionPane showMessageDialog)

當程序的main方法調用start方法 SwingWorker啟動一個新的線程來實例化ExpensiveDialogComponent main方法還構造了由一個窗口和一個按鈕組成的GUI 當用戶點擊按鈕 程序將阻塞 假如必要 阻塞到ExpensiveDialogComponent創建完成 然後程序顯示一個包含ExpensiveDialogComponent的模式對話框 你可以在MyApplication java找到整個程序 使用Timer類Timer類通過一個ActionListener來執行或多次執行一項操作 你創建定時器的時候可以指定操作執行的頻率 並且你可以指定定時器的動作事件的監聽者 啟動定時器後 動作監聽者的actionPerformed方法會被調用來執行操作 定時器動作監聽者定義的actionPerformed方法將在事件派發線程中調用 這意味著你不必在其中使用invokeLater方法 這是一個使用Timer類來實現動畫循環的例子

publicvoidstartAnimationelse } publicvoidstopAnimation publicvoidactionPerformed }

在一個線程中執行所有的用戶界面代碼有這樣一些優點 組件開發者不必對線程編程有深入的理解 像ViewPoint和Trestle這類工具包中的所有組件都必須完全支持多線程訪問 使得擴展非常困難 尤其對不精通線程編程的開發者來說 最近的一些工具包如SubArctic和IFC 都採用和Swing類似的設計 事件以可預知的次序派發 invokeLater排隊的runnable對象從滑鼠和鍵盤事件 定時器事件 繪制請求的同一個隊列派發 在一些組件完全支持多線程訪問的工具包中 組件的改變被變化無常的線程調度程序穿插到事件處理過程中 這使得全面測試變得困難甚至不可能 更低的代價 嘗試小心鎖住臨界區的工具包要花費實足的時間和空間在鎖的治理上 每當工具包中調用某個可能在客戶代碼中實現的方法時 工具包都要保存它的狀態並釋放所有鎖 以便客戶代碼能在必要時獲得鎖 當控制權交回到工具包 工具包又必須重新抓住它的鎖並恢復狀態 所有應用程序都不得不負擔這一代價 即使大多數應用程序並不需要對GUI的並發訪問 這是的SubArcticJavaToolkit的對在工具包中支持多線程訪問的問題的描述 我們的基本信條是 當設計和建造多線程應用程序 尤其是那些包括GUI組件的應用程序時 必須保證極端小心 線程的使用可能會很有欺騙性 在許多情況下 它們表現得能夠極好的簡化編成 使得設計 專注於單一任務的簡單自治實體 成為可能 在一些情況下它們的確簡化了設計和編碼 然而 在幾乎所有的情況下 它們都使得調試 測試和維護的困難大大增加甚至成為不可能 無論大多數程序員所受的練習 他們的經驗和實踐 還是我們用來幫助自己的工具 都不是能夠用來對付非決定論的 例如 全面測試在bug依靠於時間時是幾乎不可能的 尤其對於Java來說 一個程序要運行在許多不同類型的機器的操作系統平台上 並且每個程序都必須在搶先和非搶先式調度下都能正常工作 由於這些固有的困難 我們力勸你三思是否絕對有使用線程的必要 盡管如此 有些情況下使用線程是必要的 所以subArctic提供了一個線程安全的訪問機制

4. 如何判斷 Java 線程並發的安全性

總的結論：java是線程安全的，即對任何方法（包括靜態方法）都可以不考慮線程沖突，但有一個前提，就是不能存在全局變數。如果存在全局變數，則需要使用同步機制。

如下通過一組對比例子從頭講解：
在多線程中使用靜態方法會發生什麼事？也就是說多線程訪問同一個類的static靜態方法會發生什麼事？是否會發生線程安全問題？
public class Test {
public static void operation(){
// ... do something
}
}
事實證明只要在靜態函數中沒有處理多線程共享數據，就不存在著多線程訪問同一個靜態方法會出現資源沖突的問題。下面看一個例子：
public class StaticThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
StaticAction.print();
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new StaticThread()).start();
}
}
}
public class StaticAction {
public static int i = 0;
public static void print() {
int sum = 0;
for (int i = 0; i < 10; i++) {
System.out.print("step " + i + " is running.");
sum += i;
}
if (sum != 45) {
System.out.println("Thread error!");
System.exit(0);
}
System.out.println("sum is " + sum);

5. Java的List如何實現線程安全

Java的List如何實現線程安全？

Collections.synchronizedList(names);效率最高，線程安全

Java的List是我們平時很常用的集合，線程安全對於高並發的場景也十分的重要，那麼List如何才能實現線程安全呢 ？

加鎖

首先大家會想到用Vector，這里我們就不討論了，首先討論的是加鎖，例如下面的代碼

public class Synchronized{

private List<String> names = new LinkedList<>();

public synchronized void addName(String name ){
names.add("abc");
}
public String getName(Integer index){
Lock lock =new ReentrantLock();
lock.lock();
try {
return names.get(index);
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
return null;
}
}

synchronized一加，或者使用lock 可以實現線程安全，但是這樣的List要是很多個，代碼量會大大增加。

java自帶類

在java中我找到自帶有兩種方法

CopyOnWriteArrayList

CopyOnWrite 寫入時復制，它使一個List同步的替代品，通常情況下提供了更好的並發性，並且避免了再迭代時候對容器的加鎖和復制。通常更適合用於迭代，在多插入的情況下由於多次的復制性能會一定的下降。

下面是add方法的源代碼

public boolean add(E e) {
final ReentrantLock lock = this.lock; // 加鎖 只允許獲得鎖的線程訪問
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 創建個長度加1的數組並復制過去
Object[] newElements = Arrays.Of(elements, len + 1);
newElements[len] = e; // 賦值
setArray(newElements); // 設置內部的數組
return true;
} finally {
lock.unlock();
}
}

Collections.synchronizedList

Collections中有許多這個系列的方法例如

主要是利用了裝飾者模式對傳入的集合進行調用 Collotions中有內部類SynchronizedList

static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;

final Collection<E> c; // Backing Collection
final Object mutex; // Object on which to synchronize

這里上面的mutex就是鎖的對象 在構建時候可以指定鎖的對象 主要使用synchronize關鍵字實現線程安全

/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
這里只是列舉SynchronizedList ，其他類類似，可以看下源碼了解下。

測試
public class Main {
public static void main(String[] args) {
List<String> names = new LinkedList<>();
names.add("sub");
names.add("jobs");
// 同步方法1 內部使用lock
long a = System.currentTimeMillis();
List<String> strings = new CopyOnWriteArrayList<>(names);
for (int i = 0; i < 100000; i++) {
strings.add("param1");
}
long b = System.currentTimeMillis();
// 同步方法2 裝飾器模式使用 synchronized
List<String> synchronizedList = Collections.synchronizedList(names);
for (int i = 0; i < 100000; i++) {
synchronizedList.add("param2");
}
long c = System.currentTimeMillis();
System.out.println("CopyOnWriteArrayList time == "+(b-a));
System.out.println("Collections.synchronizedList time == "+(c-b));
}
}

兩者內部使用的方法都不一樣，CopyOnWriteArrayList內部是使用lock進行加鎖解鎖完成單線程訪問，synchronizedList使用的是synchronize

進行了100000次添加後時間對比如下：

可以看出來還是使用了synchronize的集合工具類在添加方面更加快一些，其他方法這里篇幅關系就不測試了，大家有興趣去試一下。

6. java實現線程安全的隊列

PrintPreviewDialog pPDlg;
exec_prefix='NONE'PACKAGE='libevent'
PACKAGE_BUGREPORT=''
PACKAGE_NAME=''
PACKAGE_STRING=''
PACKAGE_TARNAME=''
PACKAGE_URL=''
PACKAGE_VERSION=''
PATH_SEPARATOR=':'

7. java什麼叫線程安全

Count.java：

[java]view plainprint?

• publicclassCount{

• privateintnum;

• publicvoidcount(){

• for(inti=1;i<=10;i++){

• num+=i;

• }

• System.out.println(Thread.currentThread().getName()+"-"+num);

• }

• }

• 在這個類中的count方法是計算1一直加到10的和，並輸出當前線程名和總和，我們期望的是每個線程都會輸出55。

ThreadTest.java：


[java]view plainprint?

• publicclassThreadTest{

• publicstaticvoidmain(String[]args){

• Runnablerunnable=newRunnable(){

• Countcount=newCount();

• publicvoidrun(){

• count.count();

• }

• };

• for(inti=0;i<10;i++){

• newThread(runnable).start();

• }

• }

• }

• 這里啟動了10個線程，看一下輸出結果：

[java]view plainprint?

• Thread-0-55

• Thread-1-110

• Thread-2-165

• Thread-4-220

• Thread-5-275

• Thread-6-330

• Thread-3-385

• Thread-7-440

• Thread-8-495

• Thread-9-550

• 只有Thread-0線程輸出的結果是我們期望的，而輸出的是每次都累加的，這里累加的原因以後的博文會說明，那麼要想得到我們期望的結果，有幾種解決方案：

1. 將Count中num變成count方法的局部變數；


[java]view plainprint?

• publicclassCount{

• publicvoidcount(){

• intnum=0;

• for(inti=1;i<=10;i++){

• num+=i;

• }

• System.out.println(Thread.currentThread().getName()+"-"+num);

• }

• }

2. 將線程類成員變數拿到run方法中，這時count引用是線程內的局部變數；


[java]view plainprint?

• publicclassThreadTest4{

• publicstaticvoidmain(String[]args){

• Runnablerunnable=newRunnable(){

• publicvoidrun(){

• Countcount=newCount();

• count.count();

• }

• };

• for(inti=0;i<10;i++){

• newThread(runnable).start();

• }

• }

• }

3. 每次啟動一個線程使用不同的線程類，不推薦。
上述測試，我們發現，存在成員變數的類用於多線程時是不安全的，不安全體現在這個成員變數可能發生非原子性的操作，而變數定義在方法內也就是局部變數是線程安全的。想想在使用struts1時，不推薦創建成員變數，因為action是單例的，如果創建了成員變數，就會存在線程不安全的隱患，而struts2是每一次請求都會創建一個action，就不用考慮線程安全的問題。所以，日常開發中，通常需要考慮成員變數或者說全局變數在多線程環境下，是否會引發一些問題。