java import thread_Java新建线程的3种方法

Java新建线程的3种方法

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

Java创建线程有3种方法：

(1)继承Thread;

(2)实现Runnable接口；

(3)实现Callable接口;

由于Java只支持单继承，所以用继承的方式创建线程，比较死板，不够灵活；用实现接口的方式创建线程，可以实现多个接口，比较灵活。

Runnable和Callable接口的区别：

(1)Callable重写的方法是call(),Runnable重写的方法是run();

(2)Callable的任务执行后可返回值，而Runnable不能返回值；

(3)call方法可以抛出异常，run()不可以；

(4)运行Callable任务可以拿到一个future对象，表示异步计算的结果，

它供检查计算是否完成的方法，以等待计算完成，并检索计算的结果。通过Future对象可以了解任务的执行情况，可取消任务的执行，还可以获取执行的结果。

1.继承Thread

packagecom.java.thread;

publicclassThreadClient {

publicstaticvoidmain(String[] args) {

Print p1 = newPrint();

Print p2 = newPrint();

p1.start();

p2.start();

}

}

classPrintextendsThread{

@Override

publicvoidrun(){

for(inti=0;i<10;i++){

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

try{

Thread.sleep(2000);

} catch(InterruptedException e) {

e.printStackTrace();

}

}

}

}

2.实现Runnable接口

/**

*　　　　(1): 创建一个类,让该类实现Runnable接口

*　　　　(2): 重写run方法

*　　　　(3): 创建该类的对象

*　　　　(4): 创建Thread类的对象,然后把3中的对象作为参数传递给Thread

*　　　　(5): 启动线程

*/

packagecom.java.thread;

publicclassThreadClient1 {

publicstaticvoidmain(String[] args) {

Runnable p1 = newSalesman("Jack");

Runnable p2 = newSalesman("Iris");

Thread t1 = newThread(p1);

Thread t2 = newThread(p2);

t1.start();

t2.start();

}

}

classSalesmanimplementsRunnable{

privateintticket=100;//每个线程都拥有100张票

privateString name;

Salesman(String name){

this.name=name;

}

@Override

publicvoidrun(){

while(ticket>0){

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

try{

Thread.sleep(1000);

} catch(InterruptedException e) {

e.printStackTrace();

}

}

}

}

3.实现Callable接口

packagecom.java.thread;

importjava.util.ArrayList;

importjava.util.List;

importjava.util.concurrent.Callable;

importjava.util.concurrent.ExecutionException;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.Executors;

importjava.util.concurrent.Future;

publicclassCallType {

publicstaticvoidmain(String[] args) {

ExecutorService es = Executors.newCachedThreadPool();

List> results = newArrayList>();

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

results.add(es.submit(newTaskWithResult(i)));

}

for(Future fs : results){

try{

System.out.println(fs.get());

} catch(InterruptedException | ExecutionException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

classTaskWithResultimplementsCallable{

privateintid;

publicTaskWithResult(intid){

this.id = id;

}

@Override

publicString call()throwsException {

return"result of TaskWithResult"+ id;

}

}

4.匿名内部类

/**　　使用匿名内部类的方式实现 很少见

*　　new 类名/接口名() {

*　　　　　　方法重写 ;

*　　　} ;

*/

public class Thread4 {

public static void main(String[] args) {

//匿名实现多线程

//继承thread类

new Thread(){

public void run(){

for(int x=0;x<111;x++){

System.out.println(getName()+":"+x);

}

}

}.start();

//实现runable

new Thread(new Runnable() {

@Override

public void run() {

for(int x=0;x<100;x++){

System.out.println("wwww");

}

}

}).start();

}

}