首页 > 代码库 > java 创建线程

java 创建线程

java创建线程有3种方式:

(1)继承Thread
(2)实现Runnable接口
(3)实现Callable接口

 

1、继承Thead

  1. package com.java.thread;  
  2.   
  3. public class ThreadClient {  
  4.   
  5.     public static void main(String[] args) {  
  6.         Print p1 = new Print();  
  7.         Print p2 = new Print();  
  8.         p1.start();  
  9.         p2.start();  
  10.   
  11.     }  
  12.   
  13. }  
  14.   
  15. class Print extends Thread{  
  16.     @Override  
  17.     public void run(){  
  18.         for(int i=0;i<10;i++){  
  19.             System.out.println(Thread.currentThread().getName()+":"+i);  
  20.             try {  
  21.                 Thread.sleep(2000);  
  22.             } catch (InterruptedException e) {  
  23.                 e.printStackTrace();  
  24.             }  
  25.         }  
  26.     }  
  27. }  

 

2、实现Runnable接口

  1. package com.java.thread;  
  2.   
  3. public class ThreadClient1 {  
  4.   
  5.     public static void main(String[] args) {  
  6.         Runnable p1 = new Salesman("Jack");  
  7.         Runnable p2 = new Salesman("Iris");  
  8.           
  9.         Thread t1 = new Thread(p1);  
  10.         Thread t2 = new Thread(p2);  
  11.           
  12.         t1.start();  
  13.         t2.start();  
  14.     }  
  15.   
  16. }  
  17.   
  18. class Salesman implements Runnable{  
  19.       
  20.     private int ticket=100;
  21.     private String name;  
  22.     Salesman(String name){  
  23.         this.name=name;  
  24.     }  
  25.       
  26.     @Override  
  27.     public void run(){  
  28.         while(ticket>0){  
  29.              System.out.println(ticket--+" is saled by "+name+","+Thread.currentThread().getName());  
  30.             try {  
  31.                 Thread.sleep(1000);  
  32.             } catch (InterruptedException e) {  
  33.                 e.printStackTrace();  
  34.             }  
  35.          }  
  36.     }  
  37. }  

 

 

3、实现Callable接口

  1. package com.java.thread;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.concurrent.Callable;  
  6. import java.util.concurrent.ExecutionException;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.Future;  
  10.   
  11. public class CallType {  
  12.       
  13.     public static void main(String[] args) {  
  14.         ExecutorService es = Executors.newCachedThreadPool();  
  15.         List<Future<String>> results = new ArrayList<Future<String>>();  
  16.         for(int i=0;i<5;i++){  
  17.             results.add(es.submit(new TaskWithResult(i)));  
  18.         }  
  19.           
  20.         for(Future<String> fs : results){  
  21.             try {  
  22.                 System.out.println(fs.get());  
  23.             } catch (InterruptedException | ExecutionException e) {  
  24.                 // TODO Auto-generated catch block  
  25.                 e.printStackTrace();  
  26.             }  
  27.         }  
  28.     }  
  29. }  
  30.   
  31. class TaskWithResult implements Callable<String>{  
  32.     private int id;  
  33.     public TaskWithResult(int id){  
  34.         this.id = id;  
  35.     }  
  36.     @Override  
  37.     public String call() throws Exception {  
  38.         return "result of TaskWithResult" + id;  
  39.     }  
  40. }  

 

由于Java只支持单继承,所以用继承的方式创建线程,比较死板,不够灵活;用实现接口的方式创建线程,可以实现多个接口,比较灵活。
Runnable和Callable接口的区别:
(1)Callable重写的方法是call(),Runnable重写的方法是run()。
(2)Callable的任务执行后可返回值,而Runnable不能返回值。
(3)call方法可以抛出异常,run()不可以。

java 创建线程