java多線程訪問

A. java中如何用多線程訪問資料庫

//將資料庫中的數據條數分段 public void division(){ //獲取要導入的總的數據條數 String sql3="SELECT count(*) FROM [CMD].[dbo].[my1]"; try { pss=cons.prepareStatement(sql3); rss=pss.executeQuery(); while(rss.next()){ System.out.println("總記錄條數:"+rss.getInt(1)); sum=rss.getInt(1); } //每30000條記錄作為一個分割點 if(sum>=30000){ n=sum/30000; resie=sum%30000; }else{ resie=sum; } System.out.println(n+" "+resie); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } }線程類public MyThread(int start,int end) { this.end=end; this.start=start; System.out.println("處理掉余數"); try { System.out.println("--------"+Thread.currentThread().getName()+"------------"); Class.forName(SQLSERVERDRIVER); System.out.println("載入sqlserver驅動..."); cons = DriverManager.getConnection(CONTENTS,UNS,UPS); stas = cons.createStatement(); System.out.println("連接SQLServer資料庫成功！！"); System.out.println("載入mysql驅動....."); Class.forName(MYSQLDRIVER); con = DriverManager.getConnection(CONTENT,UN,UP); sta = con.createStatement(); // 關閉事務自動提交 con.setAutoCommit(false); System.out.println("連接mysql資料庫成功！！"); } catch (Exception e) { e.printStackTrace(); } // TODO Auto-generated constructor stub } public ArrayList<Member> getAll(){ Member member; String sql1="select * from (select row_number() over (order by pmcode) as rowNum,*" + " from [CMD].[dbo].[my1]) as t where rowNum between "+start+" and "+end; try { System.out.println("正在獲取數據..."); allmembers=new ArrayList(); rss=stas.executeQuery(sql1); while(rss.next()){ member=new Member(); member.setAddress1(rss.getString("address1")); member.setBnpoints(rss.getString("bnpoints")); member.setDbno(rss.getString("dbno")); member.setExpiry(rss.getString("expiry")); member.setHispoints(rss.getString("hispoints")); member.setKypoints(rss.getString("kypoints")); member.setLevels(rss.getString("levels")); member.setNames(rss.getString("names")); member.setPmcode(rss.getString("pmcode")); member.setRemark(rss.getString("remark")); member.setSex(rss.getString("sex")); member.setTelephone(rss.getString("telephone")); member.setWxno(rss.getString("wxno")); member.setPmdate(rss.getString("pmdate")); allmembers.add(member); // System.out.println(member.getNames()); } System.out.println("成功獲取sqlserver資料庫數據！"); return allmembers; } catch (SQLException e) { // TODO Auto-generated catch block System.out.println("獲取sqlserver資料庫數據發送異常！"); e.printStackTrace(); } try { rss.close(); stas.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } public void inputAll(ArrayList<Member> allmembers){ System.out.println("開始向mysql中寫入"); String sql2="insert into test.my2 values (?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; try { ps=con.prepareStatement(sql2); System.out.println("-------------------------等待寫入數據條數: "+allmembers.size()); for(int i=0;i<allmembers.size();i++){ ps.setString(1, allmembers.get(i).getPmcode()); ps.setString(2, allmembers.get(i).getNames()); //System.out.println(allmembers.get(i).getNames()); ps.setString(3, allmembers.get(i).getSex()); ps.setString(4, allmembers.get(i).getTelephone()); ps.setString(5, allmembers.get(i).getAddress1()); ps.setString(6, allmembers.get(i).getPmdate()); ps.setString(7, allmembers.get(i).getExpiry()); ps.setString(8, allmembers.get(i).getLevels()); ps.setString(9, allmembers.get(i).getDbno()); ps.setString(10, allmembers.get(i).getHispoints()); ps.setString(11, allmembers.get(i).getBnpoints()); ps.setString(12, allmembers.get(i).getKypoints()); ps.setString(13, allmembers.get(i).getWxno()); ps.setString(14, allmembers.get(i).getRemark()); //插入命令列表 //ps.addBatch(); ps.executeUpdate(); } //ps.executeBatch(); con.commit(); ps.close(); con.close(); this.flag=false; System.out.println(Thread.currentThread().getName()+"--->OK"); } catch (SQLException e) { // TODO Auto-generated catch block System.out.println("向mysql中更新數據時發生異常！"); e.printStackTrace(); } } @Override public void run() { // TODO Auto-generated method stub while(true&&flag){ this.inputAll(getAll()); } }

B. 如何解決java 多線程問題

Java線程同步需要我們不斷的進行相關知識的學習，下面我們就來看看如何才能更好的在學習中掌握相關的知識訊息，來完善我們自身的編寫手段。希望大家有所收獲。 Java線程同步的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。 你可以調用 Thread 類的方法 getPriority（）和 setPriority（）來存取Java線程同步的優先順序，線程的優先順序界於1（MIN_PRIORITY）和10（MAX_PRIORITY）之間，預設是5（NORM_PRIORITY）。 Java線程同步 由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。 由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。 1． synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：1. public synchronized void accessVal（int newVal）； synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的Java線程同步方能獲得該鎖，重新進入可執行狀態。 這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。 在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。 synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run（）聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。 2． synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：1. synchronized（syncObject）2. {3. //允許訪問控制的代碼4. } synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。 Java線程同步的阻塞 為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個Java線程同步對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。 阻塞指的是暫停一個Java線程同步的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。

C. java多線程詳細理解

• 多線程：指的是這個程序（一個進程）運行時產生了不止一個線程

• 並行與並發：

• 並行：多個cpu實例或者多台機器同時執行一段處理邏輯，是真正的同時。

• 並發：通過cpu調度演算法，讓用戶看上去同時執行，實際上從cpu操作層面不是真正的同時。並發往往在場景中有公用的資源，那麼針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力。

• 線程安全：經常用來描繪一段代碼。指在並發的情況之下，該代碼經過多線程使用，線程的調度順序不影響任何結果。這個時候使用多線程，我們只需要關注系統的內存，cpu是不是夠用即可。反過來，線程不安全就意味著線程的調度順序會影響最終結果，如不加事務的轉賬代碼：

  

• 同步：Java中的同步指的是通過人為的控制和調度，保證共享資源的多線程訪問成為線程安全，來保證結果的准確。如上面的代碼簡單加入@synchronized關鍵字。在保證結果准確的同時，提高性能，才是優秀的程序。線程安全的優先順序高於性能。

D. 深入討論一下java的多線程是如何訪問成員變數的

這很正常啊
SystemOut和num--不是原子操作啊。在某一時刻，num=8，線程1SystemOut:8，然後被中斷，執行線程2，也是SystemOut:8，然後又被中斷執行線程3，再線程4，這時候4個線程都輸出了8，最後回到線程1執行num--。
即使是一條語句，也不能保證是原子操作，除非調用的對象說明是線程安全的，或者使用鎖、隊列，否則都不能保證並發的安全。

E. java多線程訪問

可以BC
線程同步有個同步鎖，當一個線程進入那個synchronized的方法後，就鎖起了。其他線程進不去

F. java多線程訪問問題

你的設計只是一個單例模式，但是也是有問題
public static Singleton getInstance() {
if(singleton == null)
return new Singleton(); //始終沒有給singleton賦值啊
else
return singleton;
}
可以改為return singleton=new Singleton();
這樣也有個問題 --（昨天有點事，沒有說完！）如果一個線程判斷singleton為null還沒有來的及賦值就被暫停，剛好另一個線程也運行此處給singleton賦值了，等前一個線程開始執行時就會再賦值一次。應該在加一個synchronized（this）加鎖！有點復雜，可以定義singleton 時賦值getInstance直接返回這個值就可以了.
關於多處理器的問題，我個人覺的應該是由操作系統來負責調度，我們不用去關心，所有的程序時運行在java虛擬機上的，我們只關心虛擬機就可以了。
如果運行在多伺服器上，那就應該需要的多虛擬機的同步了......這個我也沒有研究過，愛莫能助

G. 什麼是Java多線程

多線程的概念？
說起多線程，那麼就不得不說什麼是線程，而說起線程，又不得不說什麼是進程。
進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。在早期面向進程設計的計算機結構中，進程是程序的基本執行實體；在當代面向線程設計的計算機結構中，進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。
進程可以簡單的理解為一個可以獨立運行的程序單位。它是線程的集合，進程就是有一個或多個線程構成的，每一個線程都是進程中的一條執行路徑。
那麼多線程就很容易理解：多線程就是指一個進程中同時有多個執行路徑（線程）正在執行。
為什麼要使用多線程？
1.在一個程序中，有很多的操作是非常耗時的，如資料庫讀寫操作，IO操作等，如果使用單線程，那麼程序就必須等待這些操作執行完成之後才能執行其他操作。使用多線程，可以在將耗時任務放在後台繼續執行的同時，同時執行其他操作。
2.可以提高程序的效率。
3.在一些等待的任務上，如用戶輸入，文件讀取等，多線程就非常有用了。
缺點：
1.使用太多線程，是很耗系統資源，因為線程需要開辟內存。更多線程需要更多內存。
2.影響系統性能，因為操作系統需要在線程之間來回切換。
3.需要考慮線程操作對程序的影響，如線程掛起，中止等操作對程序的影響。
4.線程使用不當會發生很多問題。
總結：多線程是非同步的，但這不代表多線程真的是幾個線程是在同時進行，實際上是系統不斷地在各個線程之間來回的切換（因為系統切換的速度非常的快，所以給我們在同時運行的錯覺）。
2.多線程與高並發的聯系。
高並發：高並發指的是一種系統運行過程中遇到的一種「短時間內遇到大量操作請求」的情況，主要發生在web系統集中大量訪問或者socket埠集中性收到大量請求（例如：12306的搶票情況；天貓雙十一活動）。該情況的發生會導致系統在這段時間內執行大量操作，例如對資源的請求，資料庫的操作等。如果高並發處理不好，不僅僅降低了用戶的體驗度（請求響應時間過長），同時可能導致系統宕機，嚴重的甚至導致OOM異常，系統停止工作等。如果要想系統能夠適應高並發狀態，則需要從各個方面進行系統優化，包括，硬體、網路、系統架構、開發語言的選取、數據結構的運用、演算法優化、資料庫優化……。
而多線程只是在同/非同步角度上解決高並發問題的其中的一個方法手段，是在同一時刻利用計算機閑置資源的一種方式。
多線程在高並發問題中的作用就是充分利用計算機資源，使計算機的資源在每一時刻都能達到最大的利用率，不至於浪費計算機資源使其閑置。
3.線程的創建，停止，常用方法介紹。
1.線程的創建：
線程創建主要有2種方式，一種是繼承Thread類，重寫run方法即可；（Thread類實現了Runable介面）
另一種則是實現Runable介面，也需要重寫run方法。
線程的啟動，調用start（）方法即可。 我們也可以直接使用線程對象的run方法，不過直接使用，run方法就只是一個普通的方法了。

其他的還有： 通過匿名內部類的方法創建；實現Callable介面。。。。。

2.線程常用方法：
currentThread()方法：該方法返回當前線程的信息 .getName（）可以返回線程名稱。

isAlive()方法：該方法判斷當前線程是否處於活動狀態。
sleep()方法：該方法是讓「當前正在執行的線程「休眠指定的時間，正在執行的線程是指this.currentThread()返回的線程。
getId()方法：該方法是獲取線程的唯一標識。
3.線程的停止：
在java中，停止線程並不簡單，不想for。。break那樣說停就停，需要一定的技巧。

線程的停止有3種方法：
1.線程正常終止，即run()方法運行結束正常停止。
2.使用interrupt方法中斷線程。
3.使用stop方法暴力停止線程。
interrupt方法中斷線程介紹：
interrupt方法其實並不是直接中斷線程，只是給線程添加一個中斷標志。
判斷線程是否是停止狀態：
this.interrupted(); 判斷當前線程是否已經中斷。（判斷的是這個方法所在的代碼對應的線程，而不是調用對象對應的線程）

this.isInterrupted(); 判斷線程是否已經中斷。（誰調用，判斷誰）

註：.interrupted()與isInterrupted()的區別：
interrupted()方法判斷的是所在代碼對應的線程是否中斷，而後者判斷的是調用對象對應的線程是否停止
前者執行後有清除狀態的功能（如連續調用兩次時，第一次返回true，則第二次會返回false）
後者沒有清除狀態的功能（兩次返回都為true）
真正停止線程的方法：
異常法：
在run方法中 使用 this.interrupted();判斷線程終止狀態，如果為true則 throw new interruptedException()然後捕獲該異常即可停止線程。

return停止線程：
在run方法中 使用 this.interrupted();判斷線程終止狀態，如果為true則return停止線程。 （建議使用異常法停止線程，因為還可以在catch中使線程向上拋，讓線程停止的事件得以傳播）。

暴力法：
使用stop()方法強行停止線程（強烈不建議使用，會造成很多不可預估的後果，已經被標記為過時）
（使用stop方法會拋出 java.lang.ThreadDeath 異常，並且stop方法會釋放鎖，很容易造成數據不一致）
註：在休眠中停止線程：
在sleep狀態下停止線程 會報異常，並且會清除線程狀態值為false；
先停止後sleep，同樣會報異常 sleep interrupted；

4.守護線程。
希望對您有所幫助！~

H. java 多線程 訪問數據問題

線程和車票應該隔離,即車票庫存和線程是沒有關系的.在構造Sell的時候把總的車票庫存,車票單獨寫一個單例類來進行管理,並且獲取車票寫成一個函數,該函數要是同步的,使用synchronized關鍵字.不要簡單通過ticket--來使得車票庫存減少. import java.util.Calendar; import java.util.Locale; public class Seller extends Thread { private String windowName; private TicketManager ticketManager; public Seller(String windowName, TicketManager ticketManager) { this.windowName = windowName; this.ticketManager = ticketManager; } public void run() { int ticketNo = ticketManager.workOff(); while (!interrupted() && ticketNo > 0) { System.out.println(windowName + "售出票號" + ticketNo + ", at [ " + Calendar.getInstance(Locale.CHINA) + " ]"); ticketNo = ticketManager.workOff(); try { sleep(100L); } catch (InterruptedException ie) { ie.printStackTrace(); } } } } public class TicketManager { private int stock; private int remaind; private static TicketManager ticketManager; public static final TicketManager getInstance() { if (ticketManager == null) { ticketManager = new TicketManager(); } return ticketManager; } private TicketManager() { stock = 100; } public synchronized int workOff() { if (stock > 0) { return stock--; } return -1; } } public class Run { public static void main(String[] args) { TicketManager ticketManager = TicketManager.getInstance(); String[] windows = new String[] {"窗口一", "窗口二", "窗口三", "窗口四", "窗口五"}; Seller[] window = new Seller[windows.length]; for (int i = 0; i < windows.length; i++) { window[i] = new Seller(windows[i], ticketManager); window[i].start(); } } }

I. java多線程問題：多個線程訪問同一資源時如何保證線程之間訪問的順序性。

敲鼓的方法上加synchronize,保證同時只有一個人敲鼓,

各線程都需要一個適合條件,例如定義一個flag,
線程1, for (true){if(flag==a) 敲鼓 else sleep(xxx);}
線程1, for (true){if(flag==b) 敲鼓 else sleep(xxx);}

J. java 多線程 兩個線程訪問兩個對象中不同的synchronized修飾的方法。（方法和對象都是同一個類的）

先上結論：兩個線程訪問不同對象中不同的synchronized方法不會受到synchronized的限制。

程序運行結果之所以這樣，原因在於run()方法的實現導致的。

線程1中，先調用m.test1()，接著Thread.sleep(1000)

線程2中，先Thread.sleep(1000)，接著調用m.test2()

主程序中，線程1與2都有可能先開始，無論誰先開始，結果都是線程1中m.test1()先結束，線程2中m.test2()後結束。

因為輪到線程2時，先Thread.sleep(1000)，將資源讓給線程1

改進方法，應該在列印時，讓線程sleep

classTest{
	synchronizedpublicvoidtest1(){
		for(intp=0;p<5;p++){
			try{
				Thread.sleep(500);
			}catch(InterruptedExceptione){
				//TODOAuto-generatedcatchblock
				e.printStackTrace();
			}
			System.out.println("s1.run.TestSynchronized_test1");
		}
	}

	synchronizedpublicvoidtest2(){

		for(intp=0;p<5;p++){
			try{
				Thread.sleep(500);
			}catch(InterruptedExceptione){
				//TODOAuto-generatedcatchblock
				e.printStackTrace();
			}
			System.out.println("s2.run.TestSynchronized_test2");
		}
	}
}

run()方法中直接調用即可

classTestSynchronized_1implementsRunnable{

	privateTestm;
	publicTestSynchronized_1(Testm){
		this.m=m;
	}

	publicvoidrun(){
		m.test1();
	}
}

classTestSynchronized_2implementsRunnable{

	privateTestm;
	publicTestSynchronized_2(Testm){
		this.m=m;
	}

	publicvoidrun(){
		m.test2();
	}
}

輸出結果如下：

s2.run.TestSynchronized_test 2

s2.run.TestSynchronized_test 2

s1.run.TestSynchronized_test 1

s1.run.TestSynchronized_test 1

s2.run.TestSynchronized_test 2

s1.run.TestSynchronized_test 1

s2.run.TestSynchronized_test 2

s1.run.TestSynchronized_test 1

s2.run.TestSynchronized_test 2