1 /**

2 * 第一种3 * 继承thread类 重写 run方法4 * 调用start方法，启动线程5 *@authorsunshine6 */

7

8 /**

9 * 第二种实现runnable接口,重写run方法10 * 接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程11 *@authorsunshine12 */

13

14 /**

15 * 第三种通过Callable和FutureTask实现线程16 * 1：创建Callable类的实现类,实现call方法17 * 2：创建Callable实现类的实现，用FutureTask来包装实现的对象18 * 3：将FutureTask对象作为target参数传递给Thread构造方法19 * 4：调用start方法，启动线程20 *@authorsunshine21 */

22

23 /**

24 * 第四种--通过线程池25 * ExecutorService是Java中对线程池定义的一个接口26 * 1：创建类，实现runnbale接口27 * 2：设置线程数量28 * 3：根据线程数量创建线程执行器29 * 4：执行器，执行线程30 * 5：关闭线程池31 *32 * 这个方法和直接实现Runable比33 * 这个方法 实现Runable接口34 * 然后实例化对象，将参数传递给线程执行器，进行执行35 *@authorsunshine36 */

37

38 ------------------第一种：通过继承Thread类---------

39 packagecom.www.thread;40

41 /**

42 * 第一种43 * 继承thread类 重写 run方法44 * 调用start方法，启动线程45 *@authorsunshine46 */

47 public class Thread1ByExtendsThread extendsThread{48 49     //重写run方法

50     public voidrun(){51         //在这里 获取当前线程的名字

52 System.out.println(Thread.currentThread().getName());53 }54 55     public  static voidmain(String[]  args){56         Thread1ByExtendsThread thread1 = newThread1ByExtendsThread();57         thread1.setName("线程1--通过实现Thread类");58         //启动线程

59 thread1.start();60 System.out.println(Thread.currentThread().toString());61 }62 }63

64

65

66        ------------------第二种：通过实现Runnablle接口---------

67 packagecom.www.thread;68

69 /**

70 * 第二种实现runnable接口,重写run方法71 * 接口实现类的实例作为target参数，传入带参的构造方法，调用start方法启动线程72 *@authorsunshine73 */

74 public classThread2ByImplRunable{75 　　public static voidmain(String[]  args){76 　　　　Thread t = new Thread(newMyThread());77 　　　　t.start();78 　　}79 }80

81 class MyThread implementsRunnable{82 　　@Override83 　　public voidrun() {84 　　　　System.out.println("通过实现Runnbale接口创建的线程"+Thread.currentThread().getName());85 　　}86 }87

88

89

90

91        ------------------第三种：通过实现CallAble接口和FutureTask包装器---------

92 packagecom.www.thread;93

94 importjava.util.concurrent.Callable;95 importjava.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 *@authorsunshine104 */

105 public classThread3ByCallableAndFutureTask {106 　public static voidmain(String[]  args){107 　　Callable callAble = new CallImpl();108 　　FutureTask task = new FutureTask(callAble);109 　　Thread t = newThread(task);110 　　System.out.println(Thread.currentThread().getName());111 　　t.start();112 　　}113 }114

115 class CallImpl implements Callable{116 　　@Override117 　　public Object call() throwsException {118 　　System.err.println(Thread.currentThread().getName()+"我是通过实现callable" +

119 　　"接口通过FutureTask包装器来实现线程");120 　　return null;121 }122 }123

124

125

126

127

128        ------------------第四种：通过线程池---------

129 packagecom.www.thread;130

131 importjava.util.concurrent.Executor;132 importjava.util.concurrent.ExecutorService;133 importjava.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 *@authorsunshine148 */

149 public classThread4ByThreadPool {150     public static  int POOL_NUM = 5;//定义最大线程数为5

151     public static voidmain(String[]  args){152         ExecutorService service =Executors.newFixedThreadPool(POOL_NUM);153         for(int i = 0; i

161 class MyThread4 implementsRunnable{162 @Override163     public voidrun() {164         System.out.println("通过线程池创建的线程"+Thread.currentThread().getName());165 }166 167 }168

169