java如何實現線程

Ⅰ java中如何實現多線程

1.實現Runnable介面
2.繼承Thread類

覆蓋裡面的 run方法 即可。~

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

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

方法1：繼承類

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方法被稱為對象調用方法，則仍然只有一個線程，並且沒有啟動新線程。

創建啟動線程實例：

(2)java如何實現線程擴展閱讀：

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

繼承方式:

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

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

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

實現方式:

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

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

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

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

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

Ⅲ java中如何實現線程的加入

{
	publicMyJoinThread()
	{
		();
	}
	publicMyJoinThread(Stringname)
	{
		super(name);
	}
	publicvoidrun()
	{
		for(inti=0;i<10;i++)
		{
			System.out.println(super.getName()+":"+i);
		}
	}
}
publicclassJoinTest
{
	publicstaticvoidmain(String[]args)
	{
		MyJoinThreadthread=newMyJoinThread("第1個線程");
		thread.start();
		for(inti=0;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()+":"+i);
			if(i==5)
			{
				try
				{
					thread.join();
				}
				catch(InterruptedExceptione)
				{
					System.out.println("線程被中斷");
				}
			}
		}
	}
}

Ⅳ java怎麼創建一個線程

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

Treadthread=newThread();

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

thread.start();

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

創建Thread的子類

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

{
publicvoidrun(){
System.out.println("MyThreadrunning");
}
}

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

MyThreadmyThread=newMyThread();
myTread.start();

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

實現Runnable介面

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

{
publicvoidrun(){
System.out.println("MyRunnablerunning");
}
}

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

Threadthread=newThread(newMyRunnable());
thread.start();

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

Ⅳ 如何在java中實現線程

1 繼承Thread類 ，使用new Thread(）.start();
public class ThreadTest extends Thread {
private static int count = 0;
public void run() {
{
System.out.println("ThreadTest" + count);
Random ran = new Random();
int time = ran.nextInt(1000);
System.out.println("休眠時間=" + time);
TimeUnit.MILLISECONDS.sleep(time);
count++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

2實現Runnable介面 使用依託於Tread 類:new Thread(new Runnable()）.start();
public class RunnableTest implements Runnable{

private static int count = 0;
public RunnableTest (){
}

public void run() {
System.out.println("RunnableTest" + count);
// 線程調度器，可以切換線程
Thread.yield();
count++;
}

}

Ⅵ java中怎樣實現多線程

//簡單的演示,四個人吃包子,各吃各的!
publicclassThreadTest{
	publicstaticvoidmain(String[]args){
		String[]arr={"張回333","李----四","-----王五答","趙六666"};
		for(inti=0;i<4;i++){
			newThread(newRunnable(){
				inta=1;
				publicvoidrun(){
					while(a<100)
					System.out.println(Thread.currentThread().getName()+"在吃包子,吃了"+(a++)+"個了");
				}
			},arr[i]){
			}.start();
		}
	}
}

Ⅶ java中有幾種方法可以實現一個線程

java5以前，有如下兩種：
有兩種實現方法，分別使用new Thread()和new Thread(runnable)形式，第一種直接調用thread的run方法，所以，我們往往使用Thread子類，即new SubThread()。第二種調用runnable的run方法。
第一種：
new Thread(){}.start();這表示調用Thread子類對象的run方法，new Thread(){}表示一個Thread的匿名子類的實例對象，子類加上run方法後的代碼如下：
new Thread(){
public void run(){
}
}.start();

第二種：
new Thread(new Runnable(){}).start();這表示調用Thread對象接受的Runnable對象的run方法，new Runnable(){}表示一個Runnable的匿名子類的實例對象,runnable的子類加上run方法後的代碼如下：
new Thread(new Runnable(){
public void run(){
}
}
).start();
從java5開始，還有如下一些線程池創建多線程的方式：
ExecutorService pool = Executors.newFixedThreadPool(3)
for(int i=0;i<10;i++)
{
pool.execute(new Runable(){public void run(){}});
}
Executors.newCachedThreadPool().execute(new Runable(){public void run(){}});
Executors.newSingleThreadExecutor().execute(new Runable(){public void run(){}});

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