java多線程實例代碼

⑴ 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就實現了 通信。
這種方式，本質上就是「共享內存」式的通信。多個線程需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。

⑵ 如何使用Java編寫多線程程序(1)

一、簡介1、什麼是線程要說線程，就必須先說說進程，進程就是程序的運行時的一個實例。線程呢可以看作單獨地佔有CPU時間來執行相應的代碼的。對早期的計算機（如DOS）而言，線程既是進程，進程既是進程，因為她是單線程的。當然一個程序可以是多線程的，多線程的各個線程看上去像是並行地獨自完成各自的工作，就像一台一台計算機上運行著多個處理機一樣。在多處理機計算機上實現多線程時，它們確實可以並行工作，而且採用適當的分時策略可以大大提高程序運行的效率。但是二者還是有較大的不同的，線程是共享地址空間的，也就是說多線程可以同時讀取相同的地址空間，並且利用這個空間進行交換數據。 2、為什麼要使用線程為什麼要使用多線程呢？學過《計算機體系結構》的人都知道。將順序執行程序和採用多線程並行執行程序相比，效率是可以大大地提高的。比如，有五個線程thread1, thread2, thread3, thread4, thread5，所耗的CPU時間分別為4，5，1，2，7。（假設CPU輪換周期為4個CPU時間，而且線程之間是彼此獨立的）順序執行需要花費1Array個CPU時間，而並行需要的時間肯定少於1Array個CPU時間，至於具體多少時間要看那些線程是可以同時執行的。這是在非常小規模的情況下，要是面對大規模的進程之間的交互的話，效率可以表現得更高。 3、java中是如何實現多線程的與其他語言不一樣的是，線程的觀念在java是語言中是重要的，根深蒂固的，因為在java語言中的線程系統是java語言自建的， java中有專門的支持多線程的API庫，所以你可以以最快的速度寫一個支持線程的程序。在使用java創建線程的時候，你可以生成一個Thread類或者他的子類對象，並給這個對象發送start()消息（程序可以向任何一個派生自 Runnable 介面的類對象發送 start() 消息的），這樣一來程序會一直執行，直到run返回為止，此時該線程就死掉了。在java語言中，線程有如下特點：§ 在一個程序中而言，主線程的執行位置就是main。而其他線程執行的位置，程序員是可以自定義的。值得注意的是對Applet也是一樣。 § 每個線程執行其代碼的方式都是一次順序執行的。 § 一個線程執行其代碼是與其他線程獨立開來的。如果諸線程之間又相互協作的話，就必須採用一定的交互機制。 § 前面已經說過，線程是共享地址空間的，如果控制不當，這里很有可能出現死鎖。 各線程之間是相互獨立的，那麼本地變數對一個線程而言就是完全獨立，私有的。所以呢，線程執行時，每個線程都有各自的本地變數拷貝。對象變數(instance variable)在線程之間是可以共享的，這也就是為什麼在java中共享數據對象是如此的好用，但是java線程不能夠武斷地訪問對象變數：他們是需要訪問數據對象的許可權的。二、准備知識 在分析這個例子之前，然我們先看看關於線程的幾個概念，上鎖，信號量，和java所提供的API。 上鎖對於大多數的程序而言，他們都需要線程之間相互的通訊來完成整個線程的生命周期，二實現線程之間同步的最簡單的辦法就是上鎖。為了防止相互關聯的兩個線程之間錯誤地訪問共享資源，線程需要在訪問資源的時候上鎖和解鎖，對於鎖而言，有讀鎖，寫鎖和讀寫鎖等不同的同步策略。在java中，所有的對象都有鎖；線程只需要使用synchronized關鍵字就可以獲得鎖。在任一時刻對於給定的類的實例，方法或同步的代碼塊只能被一個線程執行。這是因為代碼在執行之前要求獲得對象的鎖。 信號量通常情況下，多個線程所訪問為數不多的資源，那怎麼控制呢？一個比較非常經典而起非常簡單的辦法就是採用信號量機制。信號量機制的含義就是定義一個信號量，也就是說能夠提供的連接數；當有一個線程佔用了一個連接時，信號量就減一；當一個線程是放了連接時，信號量就加一。

⑶ 如何在Java 中實現多線程

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

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

⑷ 求一個JAVA多線程例子，最好有代碼，謝謝啦！

package a.b.test;
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Calculate1000 implements Callable<Integer>{
public Calculate1000(){}

public Calculate1000(int a, int b){
this.a = a;
this.b = b;

}

int a;
int b;

/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//同步
Calculate1000 ca1 = new Calculate1000();
Date ds1 = new Date();
int result = 0;
for(int i = 1 ; i <= 1000 ; i++){
result = ca1.add(i, result);
}
System.out.println(result);
System.out.println("同步用時" + (new Date().getTime() - ds1.getTime()) + "MS");

//非同步
Date ds2 = new Date();
result = 0;
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Integer> future1 = es.submit(new Calculate1000(1,500));
Future<Integer> future2 = es.submit(new Calculate1000(501,1000));
result = future1.get() + future2.get();
System.out.println(result);
System.out.println("非同步用時" + (new Date().getTime() - ds2.getTime()) + "MS");
es.shutdown();
}
private int add(int a, int b) throws Exception{
Thread.sleep(10);
return a + b;
}
@Override
public Integer call() throws Exception {
int res = 0;
for(int i = a ; i <= b ; i++){
res = this.add(res, i);
}
return res;
}
}
樓主你試一下這段代碼行不行，行的話請採納！

⑸ java 多線程的例子

多線程實際上就是多個線程同時運行，至於那個先完成是不能確定的。

* @author Rollen-Holt 實現Runnable介面

* */

class hello implements Runnable {

public hello() {

}

public hello(String name) {

this.name = name;

}

public void run() {

for (int i = 0; i < 5; i++) {

System.out.println(name + "運行 " + i);

}

}

public static void main(String[] args) {

hello h1=new hello("線程A");

Thread demo= new Thread(h1);

hello h2=new hello("線程B");

Thread demo1=new Thread(h2);

demo.start();

demo1.start();

}

private String name;

}

可能運行結果：

⑹ 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資源交給下一個線程執行。

⑺ java多線程編程代碼如下，輸出結果如下:

首先，你同步的是具體的某個Test實例， 對於那個實例來說，實際上只有一個線程訪問了那個代碼塊，但是sum和other卻是多個線程同時去進行訪問，實際上這是不安全的，如果你想實現每次都輸出10000的效果，那麼正確的應該是在Test.class上加鎖，而不是獲取Test實例的鎖，修改後的代碼如下：

publicclassTestextendsThread{

publicstaticintsum=10000;

publicstaticintother=0;

publicvoidgetMoney(){
synchronized(Test.class){

System.out.println(Thread.currentThread().getName()+"開始執行");
sum=sum-100;

System.out.println("sum-100");

other=other+100;

System.out.println("other+100");

System.out.println(sum+other);
System.out.println(Thread.currentThread().getName()+"執行完成");
}

}

publicvoidrun(){

getMoney();

}

publicstaticvoidmain(String[]agrs){

Threadt[]=newThread[10];

for(inti=0;i<=9;i++){

t[i]=newTest();

t[i].start();

}

}

}

// 上面代碼能得到你的結果

⑻ 如何用Java編寫多線程

在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另外一種是實現Runable介面。
對於直接繼承Thread的類來說，代碼大致框架是：
?
123456789101112 class 類名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } 屬性1； 屬性2； … }
先看一個簡單的例子：
?
/** * @author Rollen-Holt 繼承Thread類,直接調用run方法 * */class hello extends Thread { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "運行 " + i); } } public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.run(); h2.run(); } private String name; }
【運行結果】：
A運行 0
A運行 1
A運行 2
A運行 3
A運行 4
B運行 0
B運行 1
B運行 2
B運行 3
B運行 4
我們會發現這些都是順序執行的，說明我們的調用方法不對，應該調用的是start（）方法。
當我們把上面的主函數修改為如下所示的時候：
?
123456 public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.start(); h2.start(); }
然後運行程序，輸出的可能的結果如下：
A運行 0
B運行 0
B運行 1
B運行 2
B運行 3
B運行 4
A運行 1
A運行 2
A運行 3
A運行 4
因為需要用到CPU的資源，所以每次的運行結果基本是都不一樣的，呵呵。
注意：雖然我們在這里調用的是start（）方法，但是實際上調用的還是run（）方法的主體。
那麼：為什麼我們不能直接調用run（）方法呢？
我的理解是：線程的運行需要本地操作系統的支持。
如果你查看start的源代碼的時候，會發現：
?
1234567891011121314151617 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". */ if (threadStatus != 0 || this != me) throw new IllegalThreadStateException(); group.add(this); start0(); if (stopBeforeStart) { stop0(throwableFromStop); } } private native void start0();
注意我用紅色加粗的那一條語句，說明此處調用的是start0（）。並且這個這個方法用了native關鍵字，次關鍵字表示調用本地操作系統的函數。因為多線程的實現需要本地操作系統的支持。
但是start方法重復調用的話，會出現java.lang.IllegalThreadStateException異常。
通過實現Runnable介面：

大致框架是：
?
123456789101112 class 類名 implements Runnable{ 方法1; 方法2； … public void run(){ // other code… } 屬性1； 屬性2； … }

來先看一個小例子吧：
?
2930 /** * @author Rollen-Holt 實現Runnable介面 * */class hello implements Runnable { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "運行 " + i); } } public static void main(String[] args) { hello h1=new hello("線程A"); Thread demo= new Thread(h1); hello h2=new hello("線程B"); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }
【可能的運行結果】：
線程A運行 0
線程B運行 0
線程B運行 1
線程B運行 2
線程B運行 3
線程B運行 4
線程A運行 1
線程A運行 2
線程A運行 3
線程A運行 4

關於選擇繼承Thread還是實現Runnable介面？
其實Thread也是實現Runnable介面的：
?
12345678 class Thread implements Runnable { //… public void run() { if (target != null) { target.run(); } } }
其實Thread中的run方法調用的是Runnable介面的run方法。不知道大家發現沒有，Thread和Runnable都實現了run方法，這種操作模式其實就是代理模式。關於代理模式，我曾經寫過一個小例子呵呵，大家有興趣的話可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html
Thread和Runnable的區別：
如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable介面的話，則很容易的實現資源共享。
?
/** * @author Rollen-Holt 繼承Thread類，不能資源共享 * */class hello extends Thread { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5; }

【運行結果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以想像，如果這個是一個買票系統的話，如果count表示的是車票的數量的話，說明並沒有實現資源的共享。
我們換為Runnable介面：
?
12345678910111213141516171819 /** * @author Rollen-Holt 繼承Thread類，不能資源共享 * */class hello implements Runnable { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello he=new hello(); new Thread(he).start(); } private int count = 5; }

【運行結果】：
count= 5
count= 4
count= 3
count= 2
count= 1

總結一下吧：
實現Runnable介面比繼承Thread類所具有的優勢：
1）：適合多個相同的程序代碼的線程去處理同一個資源
2）：可以避免java中的單繼承的限制
3）：增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立。

所以，本人建議大家勁量實現介面。
?