java 创建线程

java创建线程有3种方式：

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

1、继承Thead

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

2、实现Runnable接口

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

3、实现Callable接口

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

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