java怎麼寫1000個執行緒

1、程式建立1000個執行緒，有可能造成系統建立大量執行緒而導致消耗完系統記憶體，還會增加建立和銷燬執行緒上所花的時間以及系統資源的開銷

2、在建立執行緒數多的情況下，可以考慮使用執行緒池

以下是Java自帶的幾種執行緒池：

(1)、newFixedThreadPool 建立一個指定工作執行緒數量的執行緒池。

每當提交一個任務就建立一個工作執行緒，如果工作執行緒數量達到執行緒池初始的最大數，則將提交的任務存入到池佇列中。

(2)、newCachedThreadPool 建立一個可快取的執行緒池。

這種型別的執行緒池特點是：

1）.工作執行緒的建立數量幾乎沒有限制（其實也有限制的，數目為Interger. MAX_VALUE）， 這樣可靈活的往執行緒池中新增執行緒。

2）.如果長時間沒有往執行緒池中提交任務，即如果工作執行緒空閒了指定的時間（預設為1分鐘），則該工作執行緒將自動終止。終止後，如果你又提交了新的任務，則執行緒池重新建立一個工作執行緒。

(3)、建立一個單執行緒化的Executor，即只建立唯一的工作者執行緒來執行任務，如果這個執行緒異常結束，會有另一個取代它，保證順序執行（我覺得這點是它的特色）。

單工作執行緒最大的特點是可保證順序地執行各個任務，並且在任意給定的時間不會有多個執行緒是活動的 。

(4)、newScheduleThreadPool 建立一個定長的執行緒池，而且支援定時的以及週期性的任務執行，類似於Timer。

3、示例程式碼

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class {

public static void main(String[] args) {

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

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

cachedThreadPool.execute(new Runnable() {

public void run() {

//在這裡執行你需要的功能

}

});

}

}

}

多執行緒有兩種形式，一種是直接讓當前類繼承 Thread 重寫run方法來實現，另一種是使用 Runnable介面。推薦第二種方法。

例：

public class Counter {

public volatile static int count = 0;

public static void inc() {

//這裡延遲1秒，使得結果明顯

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

}

count++;

}

public static void main(String[] args) {

//同時啟動1000個執行緒，去進行i++計算，看看實際結果

for (int i = 0; i

多執行緒有兩種形式，一種是直接讓當前類繼承 Thread 重寫run方法來實現，另一種是使用 Runnable介面。

推薦第二種方法。 例： public class Counter { public volatile static int count = 0; public static void inc（) { //這裡延遲1秒，使得結果明顯 try { Thread.sleep(1000); } catch (InterruptedException e) { } count++; } public static void main(String[] args) { //同時啟動1000個執行緒，去進行i++計算，看看實際結果 for (int i = 0; i < 1000; i++) { new Thread(new Runnable() { @Override public void run() { Counter.inc(); } }).start（)； } //這裡每次執行的值都有可能不同，可能不為1000 System.out.println（"執行結果：Counter.count=" + Counter.count）; } }。

有三種：

(1)繼承Thread類，重寫run函式

建立：

class xx extends Thread{

public void run(){

Thread.sleep(1000) //執行緒休眠1000毫秒，sleep使執行緒進入Block狀態，並釋放資源

}}

開啟執行緒：

物件.start（) //啟動執行緒，run函式執行

(2)實現Runnable介面，重寫run函式

開啟執行緒：

Thread t = new Thread（物件） //建立執行緒物件

t.start()

(3)實現Callable介面，重寫call函式

Callable是類似於Runnable的介面，實現Callable介面的類和實現Runnable的類都是可被其它執行緒執行的任務。

Callable和Runnable有幾點不同：

①Callable規定的方法是call（)，而Runnable規定的方法是run().

②Callable的任務執行後可返回值，而Runnable的任務是不能返回值的

③call（)方法可丟擲異常，而run（)方法是不能丟擲異常的。

④執行Callable任務可拿到一個Future物件，Future表示非同步計算的結果。它提供了檢查計算是否完成的方法，以等

待計算的完成，並檢索計算的結果.通過Future物件可瞭解任務執行情況，可取消任務的執行，還可獲取任務執行的結果

//兩種方式

public class ThreadDemo extends Thread{

public void run(){

System.out.println（"執行緒"+Thread.currentThread().getName());

}

public static void main(String[] args){

ThreadDemo t1 = new ThreadDemo（)；//建立執行緒

t1.start（)；//啟動執行緒

//建立第二個執行緒

ThreadDemo t2 = new ThreadDemo（)；//建立執行緒

t2.start（)；//啟動執行緒

}

}//方式二，實現Runnable介面

public class ThreadDemo implements Runnable{

public void run(){

System.out.println（"執行緒"+Thread.currentThread().getName());

}

public static void main(String[] args){

//建立執行緒例項

ThreadDemo td = new ThreadDemo()

//建立執行緒1

Thread t1 = new Thread(td);

t1.start();

//建立執行緒2

Thread t2 = new Thread(td);

t2.start();

}

}

如果此時執行緒池中的數量小於corePoolSize，即使執行緒池中的執行緒都處於空閒狀態，也要建立新的執行緒來處理被新增的任務。

如果此時執行緒池中的數量等於 corePoolSize，但是緩衝佇列 workQueue未滿，那麼任務被放入緩衝佇列。 如果此時執行緒池中的數量大於corePoolSize，緩衝佇列workQueue滿，並且執行緒池中的數量小於maximumPoolSize，建新的執行緒來處理被新增的任務。

如果此時執行緒池中的數量大於corePoolSize，緩衝佇列workQueue滿，並且執行緒池中的數量等於maximumPoolSize，那麼通過 handler所指定的策略來處理此任務。public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)。

class Digital{

private volatile int i =0;

private volatile long total =0;

private boolean completed = false;

public void increase(){

synchronized(this){

System.out.println(Thread.currentThread().getName()+" is increasing"）； //輔助觀看結果的 ，可以註釋掉

if(++i &lt;= 1000)

total += i;

else{

this.completed = true;

this.notifyAll（)； //喚醒主執行緒

}

}

}

public long getTotal(){

return this.total;

}

public boolean isCompleted(){

return this.completed;

}

}

public class DigitalIncrease extends Thread {

Digital digital = null;

DigitalIncrease(Digital digtal){

this.digital = digtal;

start();

}

public void run(){

while(true){

if(digital.isCompleted())

break； //如果加法操作已經完成了 就退出執行緒

digital.increase();

}

}

public static void main(String [] args){

Digital digital = new Digital();

DigitalIncrease [] diArray = new DigitalIncrease[10];

for(int i = 0; i&lt;10; i++){

diArray[i]= new DigitalIncrease(digital)； //建立10個執行緒

}

//如果加法沒完成就讓主執行緒等待

try {

synchronized (digital){

while(!digital.isCompleted())

digital.wait();

}

}catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(digital.getTotal());

}

}