1 /**
2 * 第一种
3 * 继承thread类 重写 run方法
4 * 调用start方法，启动线程
5 * @author sunshine
6 */
7
8 /**
9 * 第二种实现runnable接口,重写run方法
10 * 接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程
11 * @author sunshine
12 */
13
14 /**
15 * 第三种通过Callable和FutureTask实现线程
16 * 1：创建Callable类的实现类,实现call方法
17 * 2：创建Callable实现类的实现，用FutureTask来包装实现的对象
18 * 3：将FutureTask对象作为target参数传递给Thread构造方法
19 * 4：调用start方法，启动线程
20 * @author sunshine
21 */
22
23 /**
24 * 第四种--通过线程池
25 * ExecutorService是Java中对线程池定义的一个接口
26 * 1：创建类，实现runnbale接口
27 * 2：设置线程数量
28 * 3：根据线程数量创建线程执行器
29 * 4：执行器，执行线程
30 * 5：关闭线程池
31 *
32 * 这个方法和直接实现Runable比
33 * 这个方法 实现Runable接口
34 * 然后实例化对象，将参数传递给线程执行器，进行执行
35 * @author sunshine
36 */
37
38 ------------------第一种：通过继承Thread类---------
39 package com.www.thread;
40
41 /**
42 * 第一种
43 * 继承thread类 重写 run方法
44 * 调用start方法，启动线程
45 * @author sunshine
46 */
47 public class Thread1ByExtendsThread extends Thread{
48
49 //重写run方法
50 public void run(){
51 //在这里 获取当前线程的名字
52 System.out.println(Thread.currentThread().getName());
53 }
54
55 public static void main(String[] args){
56 Thread1ByExtendsThread thread1 = new Thread1ByExtendsThread();
57 thread1.setName("线程1--通过实现Thread类");
58 //启动线程
59 thread1.start();
60 System.out.println(Thread.currentThread().toString());
61 }
62 }
63
64
65
66 ------------------第二种：通过实现Runnablle接口---------
67 package com.www.thread;
68
69 /**
70 * 第二种实现runnable接口,重写run方法
71 * 接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程
72 * @author sunshine
73 */
74 public class Thread2ByImplRunable{
75 public static void main(String[] args){
76 Thread t = new Thread(new MyThread());
77 t.start();
78 }
79 }
80
81 class MyThread implements Runnable{
82 @Override
83 public void run() {
84 System.out.println("通过实现Runnbale接口创建的线程"+Thread.currentThread().getName());
85 }
86 }
87
88
89
90
91 ------------------第三种：通过实现CallAble接口和FutureTask包装器---------
92 package com.www.thread;
93
94 import java.util.concurrent.Callable;
95 import java.util.concurrent.FutureTask;
96
97 /**
98 * 第三种通过Callable和FutureTask实现线程
99 * 1：创建Callable类的实现类,实现call方法
100 * 2：创建Callable实现类的实现，用FutureTask来包装实现的对象
101 * 3：将FutureTask对象作为target参数传递给Thread构造方法
102 * 4：调用start方法，启动线程
103 * @author sunshine
104 */
105 public class Thread3ByCallableAndFutureTask {
106 public static void main(String[] args){
107 Callable<Object> callAble = new CallImpl<Object>();
108 FutureTask<Object> task = new FutureTask<Object>(callAble);
109 Thread t = new Thread(task);
110 System.out.println(Thread.currentThread().getName());
111 t.start();
112 }
113 }
114
115 class CallImpl<Object> implements Callable<Object>{
116 @Override
117 public Object call() throws Exception {
118 System.err.println(Thread.currentThread().getName()+"我是通过实现callable" +
119 "接口通过FutureTask包装器来实现线程");
120 return null;
121 }
122 }
123
124
125
126
127
128 ------------------第四种：通过线程池---------
129 package com.www.thread;
130
131 import java.util.concurrent.Executor;
132 import java.util.concurrent.ExecutorService;
133 import java.util.concurrent.Executors;
134
135 /**
136 * 第四种--通过线程池
137 * ExecutorService是Java中对线程池定义的一个接口
138 * 1：创建类，实现runnbale接口
139 * 2：设置线程数量
140 * 3：根据线程数量创建线程执行器
141 * 4：执行器，执行线程
142 * 5：关闭线程池
143 *
144 * 这个方法和直接实现Runable比
145 * 这个方法 实现Runable接口
146 * 然后实例化对象，将参数传递给线程执行器，进行执行
147 * @author sunshine
148 */
149 public class Thread4ByThreadPool {
150 public static int POOL_NUM = 5;//定义最大线程数为5
151 public static void main(String[] args){
152 ExecutorService service = Executors.newFixedThreadPool(POOL_NUM);
153 for(int i = 0; i<POOL_NUM; i++){
154 MyThread4 thread = new MyThread4();
155 service.execute(thread);
156 }
157 service.shutdown();
158 }
159 }
160
161 class MyThread4 implements Runnable{
162 @Override
163 public void run() {
164 System.out.println("通过线程池创建的线程"+Thread.currentThread().getName());
165 }
166
167 }
168
169
