java多線程參數

Ⅰ java多線程中sleep方法中參數為負數和正數有什麼區別

首先這個參數是必須>=0的，如果輸入負數會拋出異常：
java.lang.IllegalArgumentException: timeout value is negative
再看看源碼中這個方法的注釋

* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schelers. The thread
* does not lose ownership of any monitors.
大概翻譯過來意思就是
當前線程休眠（暫時中止執行）指定數值（毫秒）的時長，當前線程僅僅是休眠，並不會釋放臨界資源鎖（如果有的話）

Ⅱ 請問各為大神java多線程run函數調用遞歸函數怎麼傳參數

調用的地方，給一個參數
num(XXXXXXXXXXX);

這括弧裡面，加上一個整數的參數

Ⅲ java多線程開多少上限量。

1。java的線程開啟，默認的虛擬機會分配1M的內存，但是在4G的windows上線程最多也就開到300多 ，是因為windows本身的一些限制導致。

2。虛擬機給每個線程分配的內存（棧空間）是由虛擬機參數-Xss來指定的，在不同平台上對應的默認大小可以 在oracle的官方文檔上查詢到：
http://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/jrdocs/refman /optionX.html
其中，Linux64位默認Xss值為256K，並非1M或10M

3。一個Java進程可以啟動的線程數可以通過如下公式計算：

（系統剩餘內存 - 最大堆容量Xmx - 最大方法區容量MaxPermSize）／ 最大棧空間Xss

這樣，4G的伺服器單個進程可以開多少線程，可以粗略計算出來，大概是5000個線程。

Ⅳ Java多線程是什麼意思

Java多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

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

代碼說明：
上述代碼中Executors類，提供了一系列工廠方法用於創先線程池，返回的線程池都實現了ExecutorService介面。
public static ExecutorService newFixedThreadPool(int nThreads)
創建固定數目線程的線程池。
public static ExecutorService newCachedThreadPool()
創建一個可緩存的線程池，調用execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鍾未被使用的線程。
public static ExecutorService newSingleThreadExecutor()
創建一個單線程化的Executor。
public static ScheledExecutorService newScheledThreadPool(int corePoolSize)
創建一個支持定時及周期性的任務執行的線程池，多數情況下可用來替代Timer類。

總結：ExecutoreService提供了submit()方法，傳遞一個Callable，或Runnable，返回Future。如果Executor後台線程池還沒有完成Callable的計算，這調用返回Future對象的get()方法，會阻塞直到計算完成。

Ⅳ java多線程方法有哪些

java實現線程常用到的方法有三種，供參考：

/**
*方法一：繼承Thread類
*
*@authorqd
*
*/
{

@Override
publicvoidrun(){

System.out.println("run方法裡面編寫業務代碼");
}

publicstaticvoidmain(String[]args){

MyThreadmyThread=newMyThread();
//調用start方法啟動線程
myThread.start();

MyThread1myThread1=newMyThread1();
Threadthread=newThread(myThread1);
//調用start方法啟動線程
thread.start();
}

}

/**
*方法二：實現Runnable介面
*
*@authorqd
*
*/
{

@Override
publicvoidrun(){

System.out.println("run方法裡面編寫業務代碼");
}

}

/**
*方法三：實現Callable<T>介面優點：可以傳參數，有返回值類型
*
*@authorqd
*
*/
<Integer>{

@Override
publicIntegercall()throwsException{
returnnull;
}

}

Ⅵ JAVA多線程有哪幾種實現方式

JAVA多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

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

[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 在合適的地方啟動線程如下：



[java]view plain

• MyThreadmyThread1=newMyThread();

• MyThreadmyThread2=newMyThread();

• myThread1.start();

• myThread2.start();



• 2、實現Runnable介面方式實現多線程


• 如果自己的類已經extends另一個類，就無法直接extends Thread，此時，必須實現一個Runnable介面，如下：



[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 為了啟動MyThread，需要首先實例化一個Thread，並傳入自己的MyThread實例：



[java]view plain

• MyThreadmyThread=newMyThread();

• Threadthread=newThread(myThread);

• thread.start();

• 事實上，當傳入一個Runnable target參數給Thread後，Thread的run()方法就會調用target.run()，參考JDK源代碼：



[java]view plain

• publicvoidrun(){

• if(target!=null){

• target.run();

• }

• }



• 3、使用ExecutorService、Callable、Future實現有返回結果的多線程


• ExecutorService、Callable、Future這個對象實際上都是屬於Executor框架中的功能類。想要詳細了解Executor框架的可以訪問http://www.javaeye.com/topic/366591 ，這裡面對該框架做了很詳細的解釋。返回結果的線程是在JDK1.5中引入的新特徵，確實很實用，有了這種特徵我就不需要再為了得到返回值而大費周折了，而且即便實現了也可能漏洞百出。


• 可返回值的任務必須實現Callable介面，類似的，無返回值的任務必須Runnable介面。執行Callable任務後，可以獲取一個Future的對象，在該對象上調用get就可以獲取到Callable任務返回的Object了，再結合線程池介面ExecutorService就可以實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5下驗證過沒問題可以直接使用。

Ⅶ java 多線程死循環怎麼動態傳參急！

用繼承的方式實現Thread類,取名MyThread,在MyThread裡面加一個屬性 private Thread otherThread;並且給get,set方法.
在run方法裡面的死循環中判斷,if(otherThread!=null){取你要的參數};
這樣一來,在new完thread1和thread2之後,調用thread2.setOtherThread(thread1);
然後再去start.
當然,還要給MyThread加一些屬性存放你要傳遞的參數,在thread1的死循環里操作這些屬性.

Ⅷ 高人 java多線程 synchronized() 括弧裡面的參數不同結果也不同 求解 下面是我寫的代碼

第一個鎖用的this,this是一個指向對象的引用的關鍵字,所以你第一個鎖實際是鎖住了對A的引用,而程序中你創建了兩個引用分別指向A的兩個實例,所以鎖沒有生效
第二個鎖直接鎖住了類B,所以在實際程序調用中就會按照你鎖的順序進行

這樣修改一下就能看出你鎖住的是對A的一個實例的引用了

class ThreadTest extends Thread
{
B b;
public ThreadTest(B b){
this.b=b;
}
public void run(){
synchronized(this)
{
b.test();
System.out.println(getName()+"方法開始停止");
try
{
sleep(5000);
}
catch (Exception e)
{
}
System.out.println(getName()+"方法重新運行");
}
}
public static void main(String[] args)
{
B obj=new B();
ThreadTest obj1=new ThreadTest(obj);
// ThreadTest obj2=new ThreadTest(obj);

Thread a1 = new Thread(obj1);

Thread a2 = new Thread(obj1);

// Thread a2 = new Thread(obj2);

a1.start();

a2.start();
// obj1.start();
// obj2.start();
}
}
class B
{
public void test(){

System.out.println("我是B方法");
}
}

Ⅸ java里的關於多線程建立一個線程，建立一個對象，在線程類裡面把對象做參數。

這要看你這兩個線程使用是不是同一個對象，我寫個例子，你仔細看一下

publicclassTest{
	
	{
		privateintflag=0;
		publicMyThreads(){
		}
		
		@Override
		publicvoidrun(){
			System.out.println("flag="+(++flag));
		}
	}
	
	publicTest(){
		System.out.println("兩條線程同用一個對象");
		MyThreadsmyThread=newMyThreads();
		newThread(myThread).start();
		newThread(myThread).start();
	}
	
	publicTest(inti){
		System.out.println("兩條線程使用不同對象");
		MyThreadsmyThread=newMyThreads();
		newThread(myThread).start();
		MyThreadsmyThread2=newMyThreads();
		newThread(myThread2).start();
	}
	
	publicstaticvoidmain(String[]args){
		Testt=newTest();
		try{
			//線程輸出太快，先暫停一會
			Thread.currentThread().sleep(2000);
		}catch(InterruptedExceptione){
			e.printStackTrace();
		}
		Testt2=newTest(1);
	}
}

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