/**
*
第一种
*
继承thread类 重写 run方法
* 调用start方法,启动线程
* @author sunshine
*/
/**
* 第
二种实现runnable接口,重写run方法
*
接口实现类的实例作为target参数,传入带参的构造方法,调用start方法启动线程
* @author sunshine
*/
/**
*
第三种通过Callable和FutureTask实现线程
* 1:创建Callable类的实现类,实现call方法
* 2:创建Callable实现类的实现,用FutureTask来包装实现的对象
* 3:将FutureTask对象作为target参数传递给Thread构造方法
* 4:调用start方法,启动线程
* @author sunshine
*/
/**
*
第四种--通过线程池
*
ExecutorService是Java中对线程池定义的一个接口
* 1:创建类,实现runnbale接口
* 2:设置线程数量
* 3:根据线程数量创建线程执行器
* 4:执行器,执行线程
* 5:关闭线程池
*
* 这个方法和直接实现Runable比
* 这个方法 实现Runable接口
* 然后实例化对象,将参数传递给线程执行器,进行执行
* @author sunshine
*/
------------------第一种:通过继承Thread类---------
package com.www.thread;
/**
* 第一种
* 继承thread类 重写 run方法
* 调用start方法,启动线程
* @author sunshine
*/
public class Thread1ByExtendsThread extends Thread{
//重写run方法
public void run(){
//在这里 获取当前线程的名字
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args){
Thread1ByExtendsThread thread1 = new Thread1ByExtendsThread();
thread1.setName("线程1--通过实现Thread类");
//启动线程
thread1.start();
System.out.println(Thread.currentThread().toString());
}
}
/**
* 第一种
* 继承thread类 重写 run方法
* 调用start方法,启动线程
* @author sunshine
*/
public class Thread1ByExtendsThread extends Thread{
//重写run方法
public void run(){
//在这里 获取当前线程的名字
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args){
Thread1ByExtendsThread thread1 = new Thread1ByExtendsThread();
thread1.setName("线程1--通过实现Thread类");
//启动线程
thread1.start();
System.out.println(Thread.currentThread().toString());
}
}
------------------第二种:通过实现Runnablle接口---------
package com.www.thread;
/**
* 第二种实现runnable接口,重写run方法
* 接口实现类的实例作为target参数,传入带参的构造方法,调用start方法启动线程
* @author sunshine
*/
public class Thread2ByImplRunable{
public static void main(String[] args){
Thread t = new Thread(new MyThread());
t.start();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println("通过实现Runnbale接口创建的线程"+Thread.currentThread().getName());
}
}
------------------第三种:通过实现CallAble接口和FutureTask包装器---------
package com.www.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 第三种通过Callable和FutureTask实现线程
* 1:创建Callable类的实现类,实现call方法
* 2:创建Callable实现类的实现,用FutureTask来包装实现的对象
* 3:将FutureTask对象作为target参数传递给Thread构造方法
* 4:调用start方法,启动线程
* @author sunshine
*/
public class Thread3ByCallableAndFutureTask {
public static void main(String[] args){
Callable<Object> callAble = new CallImpl<Object>();
FutureTask<Object> task = new FutureTask<Object>(callAble);
Thread t = new Thread(task);
System.out.println(Thread.currentThread().getName());
t.start();
}
}
class CallImpl<Object> implements Callable<Object>{
@Override
public Object call() throws Exception {
System.err.println(Thread.currentThread().getName()+"我是通过实现callable" +
"接口通过FutureTask包装器来实现线程");
return null;
}
}
------------------第四种:通过线程池---------
package com.www.thread;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 第四种--通过线程池
* ExecutorService是Java中对线程池定义的一个接口
* 1:创建类,实现runnbale接口
* 2:设置线程数量
* 3:根据线程数量创建线程执行器
* 4:执行器,执行线程
* 5:关闭线程池
*
* 这个方法和直接实现Runable比
* 这个方法 实现Runable接口
* 然后实例化对象,将参数传递给线程执行器,进行执行
* @author sunshine
*/
public class Thread4ByThreadPool {
public static int POOL_NUM = 5;//定义最大线程数为5
public static void main(String[] args){
ExecutorService service = Executors.newFixedThreadPool(POOL_NUM);
for(int i = 0; i<POOL_NUM; i++){
MyThread4 thread = new MyThread4();
service.execute(thread);
}
service.shutdown();
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
System.out.println("通过线程池创建的线程"+Thread.currentThread().getName());
}
}
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 第四种--通过线程池
* ExecutorService是Java中对线程池定义的一个接口
* 1:创建类,实现runnbale接口
* 2:设置线程数量
* 3:根据线程数量创建线程执行器
* 4:执行器,执行线程
* 5:关闭线程池
*
* 这个方法和直接实现Runable比
* 这个方法 实现Runable接口
* 然后实例化对象,将参数传递给线程执行器,进行执行
* @author sunshine
*/
public class Thread4ByThreadPool {
public static int POOL_NUM = 5;//定义最大线程数为5
public static void main(String[] args){
ExecutorService service = Executors.newFixedThreadPool(POOL_NUM);
for(int i = 0; i<POOL_NUM; i++){
MyThread4 thread = new MyThread4();
service.execute(thread);
}
service.shutdown();
}
}
class MyThread4 implements Runnable{
@Override
public void run() {
System.out.println("通过线程池创建的线程"+Thread.currentThread().getName());
}
}