Question

java中多线程程序是怎样执行的？？

下面程序中执行new NewThread("First");后调用NewThread类的NewThread(String th)方法，接着往下执行到t.start();后，为什么不是执行public void run()方法中的语句进而输出System.out.println("测试三");和System.out.println("测试四");后休眠1秒，而是执行System.out.println("测试二");（我是依结果来的）
运行结果为：
New thread:Thread[First,5,main]
测试一
测试二 (“测试二”在这输出不明白，我觉得在这地方输出测试三/四，然后等待1秒
New thread:Thread[Second,5,main]
测试一
测试二
New thread:Thread[Third,5,main]
测试一
测试二
测试三
First:3)
New thread:Thread[Second,5,main]
测试一
测试二
New thread:Thread[Third,5,main]
测试一
测试二
测试三
First:3
。
。
。

package hello;

public class Main
{

public static void main(String[] args)
{
new NewThread("First");

new NewThread("Second");

new NewThread("Third");

try
{

Thread.sleep(10000);
}
catch(InterruptedException e)
{
System.out.println("Mainthread Interrupted");
}
System.out.println("测试五");
System.out.println("Main thread exiting");
}

}
class NewThread implements Runnable
{
String name;
Thread t;
NewThread(String th)
{
name =th;
t=new Thread(this,name);
System.out.println("New thread:"+t);
System.out.println("测试一");
t.start();
System.out.println("测试二");
}
public void run()
{
try
{System.out.println("测试三");
for(int i=3;i>=0;i--)
{
System.out.println(name+":"+i);
System.out.println("测试四");
Thread.sleep(1000);
}
}catch(InterruptedException e)
{
System.out.println(name+"Interrupted");
}
System.out.println(name+"exiting)");
}
}

Answer 1

===========
针对你的问题补充，我再解释一下：

你还是没有理解线程的原理，你要知道2个线程完全是CPU的随机行为，总是一个执行到某一个地方停止（你也无法知道到哪个地方停止，随机的），另一个再执行，然后停止，下一个线程执行。

******* 出现1342的原因 *********
第一个线程打印出1，第二次执行到++i，也就是i等于2了，但是此刻该线程停止了，并没有进行打印。 此刻第二个线程执行，执行了++i，此刻i等于3了，并进行打印了，所以第二个打印的数字是3。

===================================

-----------------------------------------------------
执行结果不会有任何规律，完全是CPU的随机行为，这也是线程的特性。

为了证明我的回答，我将你的程序执行了20次，结果如下：
1342
1342
1234
1234
1243
1342
1342
1342
1342
1342
1234
1342
1234
1234
1243
1342
1234
1234
1324
1342

其中1342出现七次，1234出现七次，1342出现三次，1243出现两次，1324出现一次。

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

Answer 2

Thread.start()只是代表启动了一个线程，什么时候执行这要依赖于操作系统对CPU时间片的分配，另外启动一个线程是需要资源的，所以肯定会存在延迟，为什么会执行“测试二”，搞清楚，这里已经是两个线程了，一个线程是t，另外一个线程是主线程，也就是创建NewThread的线程。所以，t怎么会阻碍主线程的运行呢？

Answer 3

一个很重要的一点是你的main方法是一个主线程，在其中new出来的线程都是和主线程同步执行的，他们的执行顺序以时间片来决定

Answer 4

//写的一个多线程 是可以限制最大可同时进行线程数的一个例子．
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

//import jp.co.hitachi.jkk.ekarte.hl7.util.CSBProcLock;

/**
* バッチ自动実行のスレッド
* @author yuangui
* @see Runnable
* @version 0610-00, 2010/8/25
* @since 0610-00
*/
public class CSBatDEMOThread extends Thread {

public static void main(String[] args) {
Thread t = new CSBatDEMOThread();
t.start();
}

/**
* バッチ自动実行
* @return なし
*/
@Override
public void run() {

// CSBProcLock locker = CSBProcLock.createLocker();
ExecutorService es;
try{
// locker.onStart();

//int cpuNums = Runtime.getRuntime().availableProcessors();
//Process 3 threads in the pool
es = Executors.newFixedThreadPool(10);

List<Future<?>> fs = new ArrayList<Future<?>>();

for (int i = 0; i < 100; i++) {
// TODO : logic > Start

TestTask t = new TestTask();
t.setTaskNo(this.toString() + ": " + i);

// TODO : logic End
Future<?> f = es.submit(t);
fs.add(f);
}

for (Future<?> f: fs) {
f.get();
}

//After all submitted tasks are executed,shut down the ExecutorService
if (es.isTerminated()) {
es.shutdown();
}

} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
} finally {
// locker.onEnd();
System.gc();
}
}

}

class TestTask implements Runnable{

String taskNo = "";

@Override
public void run() {
// TODO 自动生成されたメソッド・スタブ

Long wt = Math.round(Math.random() * 1000);
try {

Thread.sleep(wt);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}

System.out.println(taskNo + " time:" + wt + "ms");

}

/**
* taskNoを取得します。
* @return taskNo
*/
public String getTaskNo() {
return taskNo;
}

/**
* taskNoを设定します。
* @param taskNo taskNo
*/
public void setTaskNo(String taskNo) {
this.taskNo = taskNo;
}

}