當前位置：首頁 » 編程語言 » java創建一個線程

java創建一個線程

發布時間: 2021-03-11 20:04:54

㈠ java中如何啟動一個新的線程

java開啟新線程的三種方法：

方法1：繼承Thread類

1）：定義一個繼承自Java.lang.Thread類的類A.

2）：覆蓋A類Thread類中的run方法。

3）：我們編寫需要在run方法中執行的操作：run方法中的代碼，線程執行體。

4）：在main方法（線程）中，創建一個線程對象並啟動線程。

(1)創建線程類對象:

A類 a = new A類();

(2)調用線程對象的start方法:

a.start();//啟動一個線程

注意：不要調用run方法。如果run方法被稱為對象調用方法，則仍然只有一個線程，並且沒有啟動新線程。

創建啟動線程實例：

(1)java創建一個線程擴展閱讀：

啟動新線程的兩種方式對比

繼承方式:

1):從設計上分析，Java中類是單繼承的,如果繼承了Thread了,該類就不能再有其他的直接父類了.

2):從操作上分析,繼承方式更簡單,獲取線程名字也簡單.(操作上,更簡單)

3):從多線程共享同一個資源上分析,繼承方式不能做到.

實現方式:

1):從設計上分析，Java中類可以多實現介面,此時該類還可以繼承其他類,並且還可以實現其他介面，設計更為合理.

2):從操作上分析,實現方式稍微復雜點,獲取線程名字也比較復雜,得使用Thread.currentThread()來獲取當前線程的引用.

3):從多線程共享同一個資源上分析,實現方式可以做到(是否共享同一個資源).

補充：實現方式獲取線程名字：

String name = Thread.currentThread().getName();

㈡在JAVA 中怎樣創建一個線程

package test;
import java.util.*;

public class Threadtest extends Thread{
int pauseTime;
String name;
public Threadtest(int time,String n){
pauseTime = time;
name = n;
}
public void run(){
Calendar now;
now = Calendar.getInstance();
System.out.println(name+now.get(Calendar.MINUTE)+now.get(Calendar.SECOND));
try{
Thread.sleep(pauseTime);
}catch(Exception e){
e.getStackTrace();
}
Threadtest2 myt1 = new Threadtest2(5000,"threadin;;");
myt1.start();
}
public static void main(String[] args){
Threadtest myt1 = new Threadtest(2000,"thread1;;");
myt1.start();
Threadtest myt2 = new Threadtest(1000,"thread2;;");
myt2.start();
}

}
class Threadtest2 extends Thread{
int pauseTime;
String name;
public Threadtest2(int time,String n){
pauseTime = time;
name = n;
}
public void run(){
Calendar now;
now = Calendar.getInstance();
System.out.println(name+now.get(Calendar.MINUTE)+now.get(Calendar.SECOND));
try{
Thread.sleep(pauseTime);
}catch(Exception e){
e.getStackTrace();
}
}

}

㈢ Java開發如何創建一個線程

（1）通過擴展Thread類來創建多線程

publicstaticvoidmain(String[]args){
MutliThreadm1=newMutliThread("Window1");
MutliThreadm2=newMutliThread("Window2");
MutliThreadm3=newMutliThread("Window3");
m1.start();
m2.start();
m3.start();
}
}
classMutliThreadextendsThread{
privateintticket=100;//每個線程都擁有100張票
MutliThread(Stringname){
super(name);//調用父類帶參數的構造方法
}
publicvoidrun(){
while(ticket>0){
System.out.println(ticket--+"issaledby"+Thread.currentThread().getName());
}
}
}

（2）通過實現Runnable介面來創建多線程

publicstaticvoidmain(String[]args){
MutliThreadm1=newMutliThread("Window1");
MutliThreadm2=newMutliThread("Window2");
MutliThreadm3=newMutliThread("Window3");
Threadt1=newThread(m1);
Threadt2=newThread(m2);
Threadt3=newThread(m3);
t1.start();
t2.start();
t3.start();
}
}
{
privateintticket=100;//每個線程都擁有100張票
privateStringname;
MutliThread(Stringname){
this.name=name;
}
publicvoidrun(){
while(ticket>0){
System.out.println(ticket--+"issaledby"+name);
}
}
}

㈣ Java 如何創建100個Thread 線程

「創建100個線程」和「創建1個線程」是一樣的。
(如果不一樣，只可能是你問得唐突、不清晰)
你可以把100個線程放到一個數組中。
Thread threads[]=new Thread[100];
//然後逐個生成啟動
for(int i=0;i<100;i++){
threads[i]=new Thread(//put some runnable here );
threads[i].start();
}

㈤在 java中，怎樣創建一個線程

兩種創建新線程的方式
1.定義Runnable介面的實現類,重寫run()方法
創建線程的實例的時候將這個類的實例作為參數傳遞到線程實例內部。然後再啟動：
MyRun mr = new MyRun();
Thread t1 = new Thread(mr);
t1.start();

public class TestThread1 {
public static void main(String[] args) {
Runner runner = new Runner();//創建Runnable實現類的對象
Thread thread1 = new Thread(runner);
thread1.start();//啟動一個子線程
for(int i = 0; i < 100; i++){
System.out.println("-------Main Thread:" + i);
}
}
}

class Runner implements Runnable{
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("runner:" + i);
}
}
}

2.定義Thread 的子類,重寫run()方法
創建此線程類的實例並啟動：
MyThread t1 = new MyThread();
t1.start();

public class TestThread2 {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
thread1.start();
for(int i = 0; i < 100; i++){
System.out.println("-------Main Thread:" + i);
}
}
}

class MyThread extends Thread{
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("MyThread:" + i);
}
}
}

㈥ java 如何創建一個有返回值的線程

可以通過實現Callable介面創建一個有返回值的線程，代碼如下：

importjava.util.concurrent.*;


<Integer>{

privateintcount;

publicMyThread(intcount){
this.count=count;
}

@Override
publicIntegercall()throwsException{
//此處是線程要處理的業務代碼，此處實現的是對count變數加1的操作
count+=1;
Thread.sleep(1000);
returncount;
}

publicstaticvoidmain(String[]args){

//創建線程實例
MyThreadmyThread=newMyThread(1);

//創建一個大小為10的線程池
ExecutorServiceexecutor=Executors.newFixedThreadPool(10);

//將線程提交到線程池執行
Future<Integer>future=executor.submit(myThread);

try{
//調用get方法獲取線程執行結果，在線程執行完成前該方法會一直阻塞
Integerresult=future.get();
System.out.println(result);
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}


//try{
////這種寫法可以設置線程執行的超時時間，當線程超過指定的時間還未執行完成時會拋出TimeoutException異常
////示例中表示線程超過1000毫秒還沒執行完就會拋出超時異常
//Integerresult=future.get(1000,TimeUnit.MILLISECONDS);
//System.out.println(result);
//}catch(InterruptedExceptione){
//e.printStackTrace();
//}catch(ExecutionExceptione){
//e.printStackTrace();
//}catch(TimeoutExceptione){
//e.printStackTrace();
//}
}
}

㈦ java創建線程有幾種方式

java創建線程的方式有三種
第一種是繼承Thread類實現方法run() 不可以拋異常無返回值
第二種是實現Runnable介面實現方法run() 不可以拋異常無返回值
第三種是實現Callable<T>介面,介面中要覆蓋的方法是 public <T> call() 注意:此方法可以拋異常,而前兩種不能而且此方法可以有返回值

第三種如何運行呢 Callable介面在util.concurrent包中,由線程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 參數表示最多可以運行幾個線程
e.submit(); 這個裡面參數傳實現Callable介面那個類的對象

㈧如何創建並運行 java 線程

1
2
3
4
5
6
7
8
9
10
11

創建線程，就是這樣
extends Thread 或者 implements Runnable，但是有很多問題；

所以引申出了下面的線程池
Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，
若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，
保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

㈨如何創建並運行java線程

1
2
3
4
5
6
7
8
9
10
11

創建線程，就是這樣
extends Thread 或者 implements Runnable，但是有很多問題；

所以引申出了版下面的線程池權
Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，
若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，
保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

㈩如何創建並運行Java線程

Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。可以用如下方式用java中創建一個線程：

Tread thread = new Thread();

執行該線程可以調用該線程的start()方法:

thread.start();

在上面的例子中，我們並沒有為線程編寫運行代碼，因此調用該方法後線程就終止了。

編寫線程運行時執行的代碼有兩種方式：一種是創建Thread子類的一個實例並重寫run方法，第二種是創建類的時候實現Runnable介面。接下來我們會具體講解這兩種方法：

創建Thread的子類

創建Thread子類的一個實例並重寫run方法，run方法會在調用start()方法之後被執行。例子如下：

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

可以用如下方式創建並運行上述Thread子類

MyThread myThread = new MyThread();
myTread.start();

一旦線程啟動後start方法就會立即返回，而不會等待到run方法執行完畢才返回。就好像run方法是在另外一個cpu上執行一樣。當run方法執行後，將會列印出字元串MyThread running。

你也可以如下創建一個Thread的匿名子類：

Thread thread = new Thread(){
public void run(){
System.out.println("Thread Running");
}
};
thread.start();

當新的線程的run方法執行以後，計算機將會列印出字元串」Thread Running」。

實現Runnable介面

第二種編寫線程執行代碼的方式是新建一個實現了java.lang.Runnable介面的類的實例，實例中的方法可以被線程調用。下面給出例子：

public class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable running");
}
}

為了使線程能夠執行run()方法，需要在Thread類的構造函數中傳入 MyRunnable的實例對象。示例如下：

Thread thread = new Thread(new MyRunnable());
thread.start();

當線程運行時，它將會調用實現了Runnable介面的run方法。上例中將會列印出」MyRunnable running」。

同樣，也可以創建一個實現了Runnable介面的匿名類，如下所示：

Runnable myRunnable = new Runnable(){
public void run(){
System.out.println("Runnable running");
}
}
Thread thread = new Thread(myRunnable);
thread.start();

創建子類還是實現Runnable介面？

對於這兩種方式哪種好並沒有一個確定的答案，它們都能滿足要求。就我個人意見，我更傾向於實現Runnable介面這種方法。因為線程池可以有效的管理實現了Runnable介面的線程，如果線程池滿了，新的線程就會排隊等候執行，直到線程池空閑出來為止。而如果線程是通過實現Thread子類實現的，這將會復雜一些。

有時我們要同時融合實現Runnable介面和Thread子類兩種方式。例如，實現了Thread子類的實例可以執行多個實現了Runnable介面的線程。一個典型的應用就是線程池。

常見錯誤：調用run()方法而非start()方法

創建並運行一個線程所犯的常見錯誤是調用線程的run()方法而非start()方法，如下所示：

Thread newThread = new Thread(MyRunnable());
newThread.run(); //should be start();

起初你並不會感覺到有什麼不妥，因為run()方法的確如你所願的被調用了。但是，事實上,run()方法並非是由剛創建的新線程所執行的，而是被創建新線程的當前線程所執行了。也就是被執行上面兩行代碼的線程所執行的。想要讓創建的新線程執行run()方法，必須調用新線程的start方法。

線程名

當創建一個線程的時候，可以給線程起一個名字。它有助於我們區分不同的線程。例如：如果有多個線程寫入System.out，我們就能夠通過線程名容易的找出是哪個線程正在輸出。例子如下：

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "New Thread");
thread.start();
System.out.println(thread.getName());

需要注意的是，因為MyRunnable並非Thread的子類，所以MyRunnable類並沒有getName()方法。可以通過以下方式得到當前線程的引用：

Thread.currentThread();

因此，通過如下代碼可以得到當前線程的名字：

String threadName = Thread.currentThread().getName();

線程代碼舉例：

這里是一個小小的例子。首先輸出執行main()方法線程名字。這個線程JVM分配的。然後開啟10個線程，命名為1~10。每個線程輸出自己的名字後就退出。

public class ThreadExample {
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread("" + i){
public void run(){
System.out.println("Thread: " + getName() + "running");
}
}.start();
}
}
}

需要注意的是，盡管啟動線程的順序是有序的，但是執行的順序並非是有序的。也就是說，1號線程並不一定是第一個將自己名字輸出到控制台的線程。這是因為線程是並行執行而非順序的。Jvm和操作系統一起決定了線程的執行順序，他和線程的啟動順序並非一定是一致的。

閱讀全文

java創建一個線程

與java創建一個線程相關的閱讀推薦