java兩個線程

1. java創建兩個線程的方法和它們的區別

方法1、通過擴展Thread類來創建多線程

假設一個影院有三個售票口，分別用於向兒童、成人和老人售票。影院為每個窗口放有100張電影票，分別是兒童票、成人票和老人票。三個窗口需要同時賣票，而現在只有一個售票員，這個售票員就相當於一個CPU，三個窗口就相當於三個線程。通過程序來看一看是如何創建這三個線程的。

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 m1.start();
7 m2.start();
8 m3.start();
9 }
10 }

1 public class MutliThread extends Thread {
2 private int ticket=100;//每個線程都擁有100張票
3
4 public MutliThread (){}
5 public MutliThread (String name){
6 super(name);
7 }
8
9 @Override
10 public void run() {
11 while(ticket>0){
12 System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
13 }
14 }
15 }

程序中定義一個線程類，它擴展了Thread類。利用擴展的線程類在MutliThreadDemo類的主方法中創建了三個線程對象，並通過start()方法分別將它們啟動。

從結果可以看到，每個線程分別對應100張電影票，之間並無任何關系，這就說明每個線程之間是平等的，沒有優先順序關系，因此都有機會得到CPU的處理。但是結果

顯示這三個線程並不是依次交替執行，而是在三個線程同時被執行的情況下，有的線程被分配時間片的機會多，票被提前賣完，而有的線程被分配時間片的機會比較

少，票遲一些賣完。

可見，利用擴展Thread類創建的多個線程，雖然執行的是相同的代碼，但彼此相互獨立，且各自擁有自己的資源，互不幹擾。

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

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 Thread t1=new Thread(m1);
7 Thread t2=new Thread(m2);
8 Thread t3=new Thread(m3);
9 t1.start();
10 t2.start();
11 t3.start();
12 }
13 }

1 public class MutliThread implements Runnable{
2 private int ticket=100;//每個線程都擁有100張票
3 private String name;
4 MutliThread(String name){
5 this.name=name;
6 }
7 public void run(){
8 while(ticket>0){
9 System.out.println(ticket--+" is saled by "+name);
10 }
11 }
12 }

由於這三個線程也是彼此獨立，各自擁有自己的資源，即100張電影票，因此程序輸出的結果和 1 結果大同小異。均是各自線程對自己的100張票進行單獨的處理，互不影響。

可見，只要現實的情況要求保證新建線程彼此相互獨立，各自擁有資源，且互不幹擾，採用哪個方式來創建多線程都是可以的。因為這兩種方式創建的多線程程序能夠實現相同的功能。

3、通過實現Runnable介面來實現線程間的資源共享

現實中也存在這樣的情況，比如模擬一個火車站的售票系統，假如當日從A地發往B地的火車票只有100張，且允許所有窗口賣這100張票，那麼每一個窗口也相當於一個線程，但是這時和前面的例子不同之處就在於所有線程處理的資源是同一個資源，即100張車票。如果還用前面的方式來創建線程顯然是無法實現的，這種情況該怎樣處理呢？看下面這個程序，程序代碼如下所示：

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m=new MutliThread();
4 Thread t1=new Thread(m);
5 Thread t2=new Thread(m);
6 Thread t3=new Thread(m);
7 t1.start();
8 t2.start();
9 t3.start();
10 }
11 }

1 public class MutliThread implements Runnable{
2 private int ticket=100;//每個線程都擁有100張票
3 public void run(){
4 while(ticket>0){
5 System.out.println(ticket--+" is saled by "+Thread.currentThread());
6 }
7 }
8 }

結果正如前面分析的那樣，程序在內存中僅創建了一個資源，而新建的三個線程都是基於訪問這同一資源的，並且由於每個線程上所運行的是相同的代碼，因此它們執行的功能也是相同的。

可見，如果現實問題中要求必須創建多個線程來執行同一任務，而且這多個線程之間還將共享同一個資源，那麼就可以使用實現Runnable介面的方式來創建多線程程序。而這一功能通過擴展Thread類是無法實現的，讀者想想看，為什麼？

實現Runnable介面相對於擴展Thread類來說，具有無可比擬的優勢。這種方式不僅有利於程序的健壯性，使代碼能夠被多個線程共享，而且代碼和數據資源相對獨立，從而特別適合多個具有相同代碼的線程去處理同一資源的情況。這樣一來，線程、代碼和數據資源三者有效分離，很好地體現了面向對象程序設計的思想。因此，幾乎所有的多線程程序都是通過實現Runnable介面的方式來完成的。

區別

第1隻線程創建的辦法有1個弊端:

線程和線程可以運行的任務概念有了1起，重用性有限制。

更多時候可以把線程和線程可以運行的任務分解開

求教高手:第1隻辦法如何解釋是線程和任務概念有了1起，如何解釋了重用性有限制

第2隻辦法如何查看出的無概念有1起 ，重用性沒有限制?

辦理解不了，著急上火，感謝感謝感謝感謝幫幫忙。

public class Th讀取Demo {

public st安奈特c void main(String[] args) {

Th讀取 p1 = new Person1();

Th讀取 p2 = new Person2();

p1.start();

p2.start();

}

}

//左右是第1隻創建線程的辦法

class Person1 extends Th讀取{

public void run(){

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

System.out.println("我是線程1");

}

}

}

class Person2 extends Th讀取{

public void run(){

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

System.out.println("我是線程2");

}

}

}

---------------------------------------------------------------------------------------------------------------------------------

public class Th讀取Demo2 {

public st安奈特c void main(String[] args) {

Runnable runnable1 = new Person3();

Runnable runnable2 = new Person4();

Th讀取 t1 = new Th讀取(runnable1);

Th讀取 t2 = new Th讀取(runnable2);

t1.start();

t2.start();

}

}

//左右是第2隻創建線程的辦法

class Person3 implements Runnable{

public void run() {

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

System.out.println("我是線程3?");

}

}

}

class Person4implements Runnable{

public void run() {

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

System.out.println("我是線程4");

}

}

}

2. java 中 如何讓一個方法內最多隻能有兩個線程訪問

信號量Semaphore。下面代碼里，一個semp的信號量初始值為5，.acquire()一次-1，.release()一次+1，如果信號量值為0的時候.acquire()就會阻塞線程，直到別的線程.release()。下面的實例是允許最多5個線程同時訪問.acquire()和.release()之間的代碼，你設置初始值為2就可以了。

publicclassSemaphoreTest{

publicstaticvoidmain(String[]args){
//線程池
ExecutorServiceexec=Executors.newCachedThreadPool();
//只能5個線程同時訪問
finalSemaphoresemp=newSemaphore(5);
//模擬20個客戶端訪問
for(intindex=0;index<20;index++){
finalintNO=index;
Runnablerun=newRunnable(){
publicvoidrun(){
try{
//獲取許可
semp.acquire();
System.out.println("Accessing:"+NO);
Thread.sleep((long)(Math.random()*10000));
//訪問完後，釋放，如果屏蔽下面的語句，則在控制台只能列印5條記錄，之後線程一直阻塞
semp.release();
}catch(InterruptedExceptione){
}
}
};
exec.execute(run);
}
//退出線程池
exec.shutdown();
}
}

給你個鏈接看看

http://blog.csdn.net/shihuacai/article/details/8856526

3. java兩個線程之間如何實現切換

仔細看看30 60關鍵點，跟sleep時間長短有關，短了可能來不及執行又換另一線程
public class Test extends Thread {
public static void main(String[] args){
new Test().start();
new Test().start();
new Test().start();
}
public void run(){
try{
for(int i=0;i<100;i++){
System.out.println(getName()+":"+i);
if(i==30){
sleep(100);
}
if(i==60){
sleep(100);
}
}
}catch(Exception e){}

}
}

4. java開兩個線程操作同一個對象會有什麼情況

如果這個對象被上線程鎖（線程安全），那麼只有一個能獲取到執行，另一個必須等待
如果只是部分代碼被上鎖，他們可以共享公共資源，上鎖部分就必須等待
如果沒有任何限制，那麼每個線程都可能創建一個新對象，互不幹擾

舉個例子，
有台列印機，列印程序，如果a.b都想列印，那麼它們必須等待先來的完成，列印程序只能有一個，線程上鎖了
有一段伺服器代碼，有兩個甚至多個網頁去請求他，他會給每一個線程創建一個一樣的對象去處理事物，而不用等待別人操作完

你說的兩個線程去操作一個對象，那應該是操作共享資源，只要沒有內存溢出等等異常是完全可以正常執行的

5. 在java中，多線程真的是多個線程同時運行嗎

多CPU當然是真多線程。就是CPU可能同時在執行4個線程。
但是不是多核也沒關系。因為線程的執行往往會掛起，等待IO之類。這時候CPU會轉到別的線程來執行。這是分時系統的一大特徵。當然人是感覺不到的。
用多線程，比如你的處理分為兩大部分，一部分產生數據，一部分顯示數據，產生數據比較耗時。（生產者消費者模型）。這個時候用多線程，一個來產生數據，一個來顯示數據。對於界面來說就不會在處理產生數據的時候產生假死的現象。
希望能幫到你。

6. java多線程如何創建多個多線程

Java 多線程的同步依靠的是對象鎖機制，這個問題需要我們不斷的學習相關的問題。下面我們就來詳細的學習下如何才能更好的進行具體內容的使用。synchronized關鍵字的背後就是利用了封鎖來實現對共享資源的互斥訪問。
下面以一個簡單的實例來進行對比分析。實例要完成的工作非常簡單，就是創建10個線程，每個線程都列印從0到99這100個數字，我們希望線程之間不會出現交叉亂序列印，而是順序地列印。
先來看第一段代碼，這里我們在run()方法中加入了synchronized關鍵字，希望能對run方法進行互斥訪問，但結果並不如我們希望那樣，這是因為這里synchronized鎖住的是this對象，即當前運行線程對象本身。 Java 多線程代碼中創建了10個線程，而每個線程都持有this對象的對象鎖，這不能實現線程的同步。
Java多線程代碼如下
1.package com.vista;
2.class MyThread implements java.lang.Runnable
3.{
4.private int threadId;
5.public MyThread(int id)
6.{
7.this.threadId = id;
8.}
9.@Override
10.public synchronized void run()
11.{
12.for (int i = 0; i < 100; ++i)
13.{
14.System.out.println("Thread ID: " + this.threadId + " : " + i);
15.}
16.}
17.}
18.public class ThreadDemo
19.{
20./**
21.* @param args
22.* @throws InterruptedException
23.*/
24.public static void main(String[] args) throws InterruptedException
25.{
26.for (int i = 0; i < 10; ++i)
27.{
28.new Thread(new MyThread(i)).start();
29.Thread.sleep(1);
30.}
31.}
32.}
以上就是對Java多線程的詳細代碼介紹。

7. java的這兩個線程先執行誰

首先，你這里不是「兩個」線程。。
你這里的是先執行
t.start();然後再迅速地跳到tt.ms();
所以，你可以說是t.start()與tt.m2()是同時執行的。
但是，由於分配線程所需要的空間需要一段時間，一般情況下是會是它的下一個語句先執行，即tt.m2()先執行。等到空間分配好之後，就是線程t的執行了

8. java中怎麼實現兩個線程的信息傳遞

java兩個線程之間可以通過使用全局變數，然後使用set和get方法就可以傳遞變數，實例如下：

publicstaticStringpub="";
publicstaticvoidmain(String[]args){
finalThreadt2=newThread(){
@Override
publicvoidrun(){
//列印線程1傳遞過來的值
System.out.println(pub);
}
};
Threadt1=newThread(){
@Override
publicvoidrun(){
Stringthread1="thread1";
//將值thread1傳遞給線程2
pub=thread1;
t2.start();
}
};
t1.start();
}

9. java 程序開了兩個線程為什麼只有一個線程執行

1 你的變數i對於兩個線程來說是全局變數，有一個線程執行完成後，i都惠變成0，while不可能再執行；
2 你的線程方法定義成了同步，也就是說只有一個線程的while執行完成後，才會執行下一個線程的邏輯；

10. JAVA多線程，怎麼總是輸出兩個同樣的

這應該是java中多線程的安全問題吧，CPU處理切換時間片的速率是非常快的，
當線程1判斷完之後還沒來得及輸出，時間片就切換到線程2上了，
然後又進行了一次判斷結果還是大於0，但是還沒等到線程2輸出就又回到了線程1，接著執行
輸出語句，比如輸出10，輸出完之後又一次回到線程2上進行第二次輸出，輸出的結果和線程1
一樣（10）。我覺得應該是臨時阻塞問題。 希望能夠採納.