一个、java创建两个线程的方法

1、从java.lang.Thread派生一个新类线程类，其覆盖run()方法

2、实现Runnable接口。重载Runnable接口中的run()方法。

使用Thread类来创建线程和创建普通类的对象的操作是一样的，线程是Thread类或者其子类的实例对象。

二、java提供的两种创建线程的差别

java中类是单继承的，当定义一个新的线程类的时候。它仅仅能扩展一个外部类。那么当创建的线程是继承自Thread类来实现的，那么此线程类无法再扩展其它类，无法实现复杂的功能。此时，自己定义的线程类假设要扩展其它类，那么能够实现Runnable接口来实现线程类的功能，同一时候又能够扩展其它外部类。避免单继承带来的局限性。

同一时候。实现Runnable接口的方式创建的线程能够处理同一资源，从而实现资源的共享。

三、线程的创建

(1)由Thread类派生

由Thread派生出来的线程类。直接new就可以。

比如：

package com.thread.demo;

public class JavaThreadDemo {

/**

* @param args

*/

public static void main(String[] args) {

MutliThread m1 = new MutliThread("window 1");

MutliThread m2 = new MutliThread("window 2");

MutliThread m3 = new MutliThread("window 3");

m1.start();

m2.start();

m3.start();

}

}

class MutliThread extends Thread {

private int ticket = 100;

MutliThread(String name) {

super(name);

}

public void run() {

while(ticket > 0) {

ticket--;

System.out.println(ticket +" is saled by " + Thread.currentThread().getName());

}

}

}上面的样例中由Thread类派生出的MutliThread类，在main()方法中new了三个线程类，并调用线程类的start方法来执行线程。三个线程并发的执行。

有输出结果能够看出。

(2)实现Runnable接口

创建的类假设实现了Runnable接口，则须要使用Thread的构造方法来创建线程。

比如：package com.thread.demo;

public class JavaThreadDemo {

/**

* @param args

*/

public static void main(String[] args) {

TestRunnable test1 = new TestRunnable("张三");

TestRunnable test2 = new TestRunnable("李四");

Thread t1 = new Thread(test1);

Thread t2 = new Thread(test2);

t1.start();

t2.start();

}

}

class TestRunnable implements Runnable {

private String name;

TestRunnable(String name) {

this.name = name;

}

@Override

public void run() {

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

try {

Thread.sleep(50);//模拟耗时操作

System.out.println(name + ":" + i);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}上面的样例中TestRunnable实现了Runnable接口，并重载了当中的run()方法，在run()方法中模拟了耗时操作。

在main()方法中，首先创建了两个TestRunnable的实例，接着调用Thread的构造方法来创建了两个线程类，最后调用线程的start()方法来执行线程。这两个线程并行执行，能够看到输出结果为

每次的输出结果都不同，由于线程的执行是不确定的。随机器和执行的状态而变化。

四、线程中须要注意的一些小问题：

1、每一个线程都有自己的名字。假设不明白指定名字。那么线程的名字由虚拟机自己分配。

主线程的名字总是main。非主线程的名字不确定，视虚拟机分配的名字而定。

全部的线程(包含主线程main)的名字都能够设置和获取它的名字。

2、获取当前线程的对象的方法：Thread.currentThread();

3、线程的运行并非按某种顺序而运行的。对于不论什么一组启动的线程来说，调度程序不能保证其运行顺序，持续时间也无法确定，上面的线程样例中。每次运行的结果都不同，正好能够说明这一点。

4、线程的run()方法执行完成，则此线程结束。一个可执行的线程或者死线程能够被又一次启动。

5、线程的调度是JVM上的一部分。在一个CPU的机器上，实际上一次仅仅能执行一个线程。一次仅仅有一个线程栈执行。JVM线程调度程序决定实际执行那个处于可执行状态的线程。

可执行状态线程被选择的顺序是不确定的。

版权声明：本文博客原创文章，博客，未经同意，不得转载。

Java线程类也是一个object类,它的实例都继承自java.lang.Thread或其子类。 可以用如下方式用java中创建一个线程：

Tread thread = new Thread();

执行该线程可以调用该线程的start()方法:

thread.start();

在上面的例子中，我们并没有为线程编写运行代码，因此调用该方法后线程就终止了。

编写线程运行时执行的代码有两种方式：一种是创建Thread子类的一个实例并重写run方法，第二种是创建类的时候实现Runnable接口。接下来我们会具体讲解这两种方法：

创建Thread的子类

创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行。例子如下：

public class MyThread extendsThread {public voidrun(){

System.out.println("MyThread running");

}

}

可以用如下方式创建并运行上述Thread子类

MyThread myThread = newMyThread();

myTread.start();

一旦线程启动后start方法就会立即返回，而不会等待到run方法执行完毕才返回。就好像run方法是在另外一个cpu上执行一样。当run方法执行后，将会打印出字符串MyThread running。

你也可以如下创建一个Thread的匿名子类：

Thread thread = newThread(){public voidrun(){

System.out.println("Thread Running");

}

};

thread.start();

当新的线程的run方法执行以后，计算机将会打印出字符串”Thread Running”。

实现Runnable接口

第二种编写线程执行代码的方式是新建一个实现了java.lang.Runnable接口的类的实例，实例中的方法可以被线程调用。下面给出例子：

public class MyRunnable implementsRunnable {public voidrun(){

System.out.println("MyRunnable running");

}

}

为了使线程能够执行run()方法，需要在Thread类的构造函数中传入MyRunnable的实例对象。示例如下：

Thread thread = new Thread(newMyRunnable());

thread.start();

当线程运行时，它将会调用实现了Runnable接口的run方法。上例中将会打印出”MyRunnable running”。

同样，也可以创建一个实现了Runnable接口的匿名类，如下所示：

Runnable myRunnable = newRunnable(){public voidrun(){

System.out.println("Runnable running");

}

}

Thread thread= newThread(myRunnable);

thread.start();

创建子类还是实现Runnable接口？

对于这两种方式哪种好并没有一个确定的答案，它们都能满足要求。就我个人意见，我更倾向于实现Runnable接口这种方法。因为线程池可以有效的管理实现了Runnable接口的线程，如果线程池满了，新的线程就会排队等候执行，直到线程池空闲出来为止。而如果线程是通过实现Thread子类实现的，这将会复杂一些。

有时我们要同时融合实现Runnable接口和Thread子类两种方式。例如，实现了Thread子类的实例可以执行多个实现了Runnable接口的线程。一个典型的应用就是线程池。

常见错误：调用run()方法而非start()方法

创建并运行一个线程所犯的常见错误是调用线程的run()方法而非start()方法，如下所示：

Thread newThread = newThread(MyRunnable());

newThread.run();//should be start();

起初你并不会感觉到有什么不妥，因为run()方法的确如你所愿的被调用了。但是，事实上，run()方法并非是由刚创建的新线程所执行的，而是被创建新线程的当前线程所执行了。也就是被执行上面两行代码的线程所执行的。想要让创建的新线程执行run()方法，必须调用新线程的start方法。

线程名

当创建一个线程的时候，可以给线程起一个名字。它有助于我们区分不同的线程。例如：如果有多个线程写入System.out，我们就能够通过线程名容易的找出是哪个线程正在输出。例子如下：

MyRunnable runnable = newMyRunnable();

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 classThreadExample {public static voidmain(String[] args){

System.out.println(Thread.currentThread().getName());for(int i=0; i<10; i++){new Thread("" +i){public voidrun(){

System.out.println("Thread: " + getName() + "running");

}

}.start();

}

}

}

这将产生如下所示结果：

需要注意的是，尽管启动线程的顺序是有序的，但是执行的顺序并非是有序的。也就是说，1号线程并不一定是第一个将自己名字输出到控制台的线程。这是因为线程是并行执行而非顺序的。JVM和操作系统一起决定了线程的执行顺序，他和线程的启动顺序并非一定是一致的。