java客戶端多線程

A. java多線程的好處

1. 充分利用CPU資源
現在世界上大多數計算機只有一塊CPU.因此，充分利用CPU資源顯得尤為重要。當執行單線程程序時，由於在程序發生阻塞時CPU可能會處於空閑狀態。這將造成大量的計算資源的浪費。而在程序中使用多線程可以在某一個線程處於休眠或阻塞時，而CPU又恰好處於空閑狀態時來運行其他的線程。這樣CPU就很難有空閑的時候。因此，CPU資源就得到了充分地利用。
2. 簡化編程模型
如果程序只完成一項任務，那隻要寫一個單線程的程序，並且按著執行這個任務的步驟編寫代碼即可。但要完成多項任務，如果還使用單線程的話，那就得在在程序中判斷每項任務是否應該執行以及什麼時候執行。如顯示一個時鍾的時、分、秒三個指針。使用單線程就得在循環中逐一判斷這三個指針的轉動時間和角度。如果使用三個線程分另來處理這三個指針的顯示，那麼對於每個線程來說就是指行一個單獨的任務。這樣有助於開發人員對程序的理解和維護。
3. 簡化非同步事件的處理
當一個伺服器應用程序在接收不同的客戶端連接時最簡單地處理方法就是為每一個客戶端連接建立一個線程。然後監聽線程仍然負責監聽來自客戶端的請求。如果這種應用程序採用單線程來處理，當監聽線程接收到一個客戶端請求後，開始讀取客戶端發來的數據，在讀完數據後，read方法處於阻塞狀態，也就是說，這個線程將無法再監聽客戶端請求了。而要想在單線程中處理多個客戶端請求，就必須使用非阻塞的Socket連接和非同步I/O.但使用非同步I/O方式比使用同步I/O更難以控制，也更容易出錯。因此，使用多線程和同步I/O可以更容易地處理類似於多請求的非同步事件。
4. 使GUI更有效率
使用單線程來處理GUI事件時，必須使用循環來對隨時可能發生的GUI事件進行掃描，在循環內部除了掃描GUI事件外，還得來執行其他的程序代碼。如果這些代碼太長，那麼GUI事件就會被「凍結」，直到這些代碼被執行完為止。
在現代的GUI框架（如SWING、AWT和SWT）中都使用了一個單獨的事件分派線程（event dispatch thread，EDT）來對GUI事件進行掃描。當我們按下一個按鈕時，按鈕的單擊事件函數會在這個事件分派線程中被調用。由於EDT的任務只是對GUI事件進行掃描，因此，這種方式對事件的反映是非常快的。
5. 節約成本
提高程序的執行效率一般有三種方法：
（1）增加計算機的CPU個數。
（2）為一個程序啟動多個進程
（3）在程序中使用多進程。
第一種方法是最容易做到的，但同時也是最昂貴的。這種方法不需要修改程序，從理論上說，任何程序都可以使用這種方法來提高執行效率。第二種方法雖然不用購買新的硬體，但這種方式不容易共享數據，如果這個程序要完成的任務需要必須要共享數據的話，這種方式就不太方便，而且啟動多個線程會消耗大量的系統資源。第三種方法恰好彌補了第一種方法的缺點，而又繼承了它們的優點。也就是說，既不需要購買CPU，也不會因為啟太多的線程而佔用大量的系統資源（在默認情況下，一個線程所佔的內存空間要遠比一個進程所佔的內存空間小得多），並且多線程可以模擬多塊CPU的運行方式，因此，使用多線程是提高程序執行效率的最廉價的方式。

B. 用java多線程實現伺服器與客戶端原理

伺服器端：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import java.net.*;
import java.util.Vector;
public class OneToMoreServer extends JFrame implements ActionListener{
JPanel contentPane;
JLabel jLabel2 = new JLabel();
JTextField jTextField2 = new JTextField("4700");
JButton jButton1 = new JButton();
JLabel jLabel3 = new JLabel();
JTextField jTextField3 = new JTextField();
JButton jButton2 = new JButton();
JScrollPane jScrollPane1 = new JScrollPane();
JTextArea jTextArea1 = new JTextArea();
ServerSocket server = null;
Socket socket = null;BufferedReader instr =null;PrintWriter os=null ;
Vector vector=new Vector();
boolean serverRun=true;
boolean clientRun=true;
//Construct the frame
public OneToMoreServer() {
jbInit();

}

class MyThread extends Thread{//該線程負責接收數據
Socket socketI=null;
BufferedReader br=null;
public MyThread(Socket socket)
{
socketI=socket;
}
public void run(){
try{
while(clientRun){
this.sleep(100);
br= new BufferedReader(new InputStreamReader(socketI.getInputStream()));
if(br.ready()){ //檢查是否有數據
jTextArea1.append("接收到來自客戶端("+socketI.getInetAddress().toString()+")的消息: "+br.readLine()+"\n");
}
}
}catch(Exception ex){JOptionPane.showMessageDialog(null,ex.toString());}
}
}

public void actionPerformed(ActionEvent e){
if(e.getSource()==jButton1){
int port=Integer.parseInt(jTextField2.getText().trim());
//監聽指定埠
try
{
server = new ServerSocket(port);
new Thread(new ListenClient()).start();
}
catch(IOException ex)
{
JOptionPane.showMessageDialog(null,ex.toString());
}
}
if(e.getSource()==jButton2){
String msg=jTextField3.getText().trim();
if(msg.length()!=0)
sendData("hello");
}
}
//該線程負責監聽指定埠
class ListenClient implements Runnable
{
public void run()
{
try{
if(jButton1.getText().trim().equals("偵聽")){
jButton1.setText("正在偵聽...");
while(serverRun)
{
Socket socketI=server.accept();//有客戶端連入時建立一個線程監聽客戶端發送的消息
vector.add(socketI);
jButton1.setText("正在聊天...");
jTextArea1.append("客戶端"+socketI.getInetAddress().toString()+"已經連接到伺服器\n");
MyThread t=new MyThread(socketI);
t.start();
}
}
}catch(Exception ex){
JOptionPane.showMessageDialog(null,ex.toString());
}
}
}

private void sendData(String s){//發送數據
try{
for(int i=0;i<vector.size();i++)
{
//怎麼廣播?????
//向每個客戶端發送一條消息
Socket socket=(Socket)vector.get(i);
os= new PrintWriter(socket.getOutputStream());
os.println(s);
os.flush();
}
}catch(Exception ex){
}
}

private void jbInit() {
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(null);
this.setSize(new Dimension(540, 340));
this.setTitle("伺服器");
jLabel2.setBounds(new Rectangle(22, 27, 72, 28));
jLabel2.setText("埠號");
jLabel2.setFont(new java.awt.Font("宋體", 0, 14));
jTextField2.setBounds(new Rectangle(113, 27, 315, 24));

jButton1.setBounds(new Rectangle(440, 28, 73, 25));
jButton1.setFont(new java.awt.Font("Dialog", 0, 14));
jButton1.setBorder(BorderFactory.createEtchedBorder());
jButton1.setActionCommand("jButton1");
jButton1.setText("偵聽");
jLabel3.setBounds(new Rectangle(23, 57, 87, 28));
jLabel3.setText("請輸入信息");
jLabel3.setFont(new java.awt.Font("宋體", 0, 14));
jTextField3.setBounds(new Rectangle(114, 60, 314, 24));
jTextField3.setText("");
jButton2.setText("廣播");
jButton2.setActionCommand("jButton1");
jButton2.setBorder(BorderFactory.createEtchedBorder());
jButton2.setFont(new java.awt.Font("Dialog", 0, 14));
jButton2.setBounds(new Rectangle(440, 58, 73, 25));
jScrollPane1.setBounds(new Rectangle(23, 92, 493, 189));

contentPane.add(jTextField2, null);
contentPane.add(jButton1, null);
contentPane.add(jLabel3, null);
contentPane.add(jTextField3, null);
contentPane.add(jButton2, null);
contentPane.add(jScrollPane1, null);
contentPane.add(jLabel2, null);
jScrollPane1.getViewport().add(jTextArea1, null);
jButton1.addActionListener(this);
jButton2.addActionListener(this);
this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
try{
socket.close();
instr.close();
System.exit(0);
}catch(Exception ex){
//JOptionPane.showMessageDialog(null,ex.toString());
}

}
});
}
public static void main(String arg[]){
JFrame.(true);
OneToMoreServer frm=new OneToMoreServer();
frm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frm.setVisible(true);
}
}

客戶端
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import java.net.*;
public class Client extends JFrame implements ActionListener{
JPanel contentPane;
JLabel jLabel1 = new JLabel();
JTextField jTextField1 = new JTextField("127.0.0.1");
JLabel jLabel2 = new JLabel();
JTextField jTextField2 = new JTextField("4700");
JButton jButton1 = new JButton();
JLabel jLabel3 = new JLabel();
JTextField jTextField3 = new JTextField();
JButton jButton2 = new JButton();
JScrollPane jScrollPane1 = new JScrollPane();
JTextArea jTextArea1 = new JTextArea();
BufferedReader instr =null;
Socket socket = null;
PrintWriter os=null;
public Client() {
jbInit();
}
class MyThread extends Thread{
public void run(){
try{
os=new PrintWriter(socket.getOutputStream());
instr=new BufferedReader(new InputStreamReader(socket.getInputStream()));
while(true)
{
this.sleep(100);
if(instr.ready())
{
jTextArea1.append("接收到來自伺服器的消息: "+instr.readLine()+"\n");
}
}
}catch(Exception ex){
JOptionPane.showMessageDialog(null,ex.toString());
}
}
}
public void actionPerformed(ActionEvent e){
if(e.getSource()==jButton1){
String ip=jTextField3.getText().trim();
int port=Integer.parseInt(jTextField2.getText().trim());
connectServer(ip,port);
}
if(e.getSource()==jButton2){
String s=this.jTextField3.getText().trim();
sendData(s);
}
}
private void connectServer(String ip,int port){//連接
try{
if(jButton1.getText().trim().equals("連接")){
jButton1.setText("連接伺服器...");
socket=new Socket(ip,port);
jButton1.setText("正在聊天");
MyThread t=new MyThread();
t.start();
}
}catch(Exception ex){
JOptionPane.showMessageDialog(this,ex.toString());
}
}
private void sendData(String s){//發送數據
try{
os = new PrintWriter(socket.getOutputStream());
os.println(s);
os.flush();
this.jTextArea1.append("向伺服器發送消息:"+s+"\n");
}catch(Exception ex){
JOptionPane.showMessageDialog(this,ex.toString());
}
}
private void jbInit() {
contentPane = (JPanel) this.getContentPane();
jLabel1.setFont(new java.awt.Font("宋體", 0, 14));
jLabel1.setText("伺服器名稱");
jLabel1.setBounds(new Rectangle(20, 22, 87, 28));
contentPane.setLayout(null);
this.setSize(new Dimension(540, 340));
this.setTitle("客戶端");

jTextField1.setBounds(new Rectangle(114, 26, 108, 24));
jLabel2.setBounds(new Rectangle(250, 25, 72, 28));
jLabel2.setText("埠號");
jLabel2.setFont(new java.awt.Font("宋體", 0, 14));
jTextField2.setBounds(new Rectangle(320, 27, 108, 24));

jButton1.setBounds(new Rectangle(440, 28, 73, 25));
jButton1.setFont(new java.awt.Font("Dialog", 0, 14));
jButton1.setBorder(BorderFactory.createEtchedBorder());
jButton1.setActionCommand("jButton1");
jButton1.setText("連接");
jLabel3.setBounds(new Rectangle(23, 57, 87, 28));
jLabel3.setText("請輸入信息");
jLabel3.setFont(new java.awt.Font("宋體", 0, 14));
jTextField3.setBounds(new Rectangle(114, 60, 314, 24));

jButton2.setText("發送");
jButton2.setActionCommand("jButton1");
jButton2.setBorder(BorderFactory.createEtchedBorder());
jButton2.setFont(new java.awt.Font("Dialog", 0, 14));
jButton2.setBounds(new Rectangle(440, 58, 73, 25));
jScrollPane1.setBounds(new Rectangle(23, 92, 493, 189));

contentPane.add(jLabel1, null);
contentPane.add(jTextField1, null);
contentPane.add(jLabel2, null);
contentPane.add(jTextField2, null);
contentPane.add(jButton1, null);
contentPane.add(jLabel3, null);
contentPane.add(jTextField3, null);
contentPane.add(jButton2, null);
contentPane.add(jScrollPane1, null);
jScrollPane1.getViewport().add(jTextArea1, null);
jButton1.addActionListener(this);
jButton2.addActionListener(this);
this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
try{
socket.close();instr.close();os.close();System.exit(0);
}catch(Exception ex){
JOptionPane.showMessageDialog(null,ex.toString());
}
}
});
}
public static void main(String arg[]){
JFrame.(true);
Client frm=new Client();
frm.setVisible(true);
}
}

C. java socket客戶端還用多線程嗎

服務端要同時為很多客戶工作的話，簡單的設計就是使用多線程，每個線程為一個客戶工作。客戶端通常不需要特別多的線程，但是一般也需要一個工作線程負責和服務端的協議處理，一個界面的線程，否則如果網路阻塞，用戶的體驗會很不好（界面總是卡殼）。當然簡單學習的話，客戶端用單線程也是可以的。

例子代碼很多Java編程的書里都有，可以在網上搜索一下。推薦還是去下載一本Java網路編程的電子書吧，不然光看實例源代碼，一些基本概念和處理方法不太容易明白為什麼要這樣做的。

D. java怎麼實現多線程

實現線程 1.繼承thread類
2.實現runnable介面

而實現多線程 多new幾次就行了 ，
比如：

mythread my = new mythread("線程a");

mythread my = new mythread("線程b");
mythread裡面是繼承的thread 重寫了run方法的

E. java程序支不支持多線程

java一個很大的特性就是支持多線程編程，程序運行開始就由虛擬機創建了一個主線程（通過查找main方法創建），程序中可以通過繼承Thread類創建自定義的其它線程，從而讓程序同時做多件事。

F. java里多線程的客戶端與伺服器怎麼實現

伺服器監聽埠 做個無限循環 接到一個連接就創建一個通道線程，並將通道線程存儲到一個list集合中 import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import

G. 什麼是Java多線程編程

一、 什麼是多線程：

我們現在所使用操作系統都是多任務操作系統(早期使用的DOS操作系統為單任務操作系統)，多任務操作指在同一時刻可以同時做多件事(可以同時執行多個程序)。

• 多進程:每個程序都是一個進程，在操作系統中可以同時執行多個程序,多進程的目的是為了有效的使用CPU資源，每開一個進程系統要為該進程分配相關的系統資源(內存資源)

• 多線程:線程是進程內部比進程更小的執行單元(執行流|程序片段),每個線程完成一個任務,每個進程內部包含了多個線程每個線程做自己的事情，在進程中的所有線程共享該進程的資源；

• 主線程:在進程中至少存在一個主線程，其他子線程都由主線程開啟,主線程不一定在其他線程結束後結束，有可能在其他線程結束前結束。Java中的主線程是main線程,是Java的main函數;

二、 Java中實現多線程的方式:

• 繼承Thread類來實現多線程:

當我們自定義的類繼承Thread類後，該類就為一個線程類,該類為一個獨立的執行單元，線程代碼必須編寫在run()方法中,run方法是由Thread類定義，我們自己寫的線程類必須重寫run方法。

run方法中定義的代碼為線程代碼，但run方法不能直接調用，如果直接調用並沒有開啟新的線程而是將run方法交給調用的線程執行

要開啟新的線程需要調用Thread類的start()方法，該方法自動開啟一個新的線程並自動執行run方法中的內容



java多線程的啟動順序不一定是線程執行的順序，各個線程之間是搶佔CPU資源執行的，所有有可能出現與啟動順序不一致的情況。

CPU的調用策略：

如何使用CPU資源是由操作系統來決定的，但操作系統只能決定CPU的使用策略不能控制實際獲得CPU執行權的程序。

線程執行有兩種方式：

1.搶占式：

目前PC機中使用最多的一種方式，線程搶佔CPU的執行權，當一個線程搶到CPU的資源後並不是一直執行到此線程執行結束，而是執行一個時間片後讓出CPU資源，此時同其他線程再次搶佔CPU資源獲得執行權。

2.輪循式;

每個線程執行固定的時間片後讓出CPU資源，以此循環執行每個線程執行相同的時間片後讓出CPU資源交給下一個線程執行。

希望對您有所幫助！~

H. 如何解決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 提供了大量方法來支持阻塞，下面讓我們逐一分析。

I. Java多線程是什麼意思

Java多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

1、繼承Thread類實現多線程
繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable介面的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：

代碼說明：
上述代碼中Executors類，提供了一系列工廠方法用於創先線程池，返回的線程池都實現了ExecutorService介面。
public static ExecutorService newFixedThreadPool(int nThreads)
創建固定數目線程的線程池。
public static ExecutorService newCachedThreadPool()
創建一個可緩存的線程池，調用execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鍾未被使用的線程。
public static ExecutorService newSingleThreadExecutor()
創建一個單線程化的Executor。
public static ScheledExecutorService newScheledThreadPool(int corePoolSize)
創建一個支持定時及周期性的任務執行的線程池，多數情況下可用來替代Timer類。

總結：ExecutoreService提供了submit()方法，傳遞一個Callable，或Runnable，返回Future。如果Executor後台線程池還沒有完成Callable的計算，這調用返回Future對象的get()方法，會阻塞直到計算完成。

J. java 如何實現多線程

線程間的通信方式
同步
這里講的同步是指多個線程通過synchronized關鍵字這種方式來實現線程間的通信。
參考示例：
public class MyObject {
synchronized public void methodA() {
//do something....
}
synchronized public void methodB() {
//do some other thing
}
}
public class ThreadA extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodA();
}
}
public class ThreadB extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
//線程A與線程B 持有的是同一個對象:object
ThreadA a = new ThreadA(object);
ThreadB b = new ThreadB(object);
a.start();
b.start();
}
}
由於線程A和線程B持有同一個MyObject類的對象object，盡管這兩個線程需要調用不同的方法，但是它們是同步執行的，比如：線程B需要等待線程A執行完了methodA()方法之後，它才能執行methodB()方法。這樣，線程A和線程B就實現了 通信。
這種方式，本質上就是「共享內存」式的通信。多個線程需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。