java创建指定id线程_java创建线程的四种方式

Java使用Thread类代表线程，所有线程都是Thread类或其子类，Java创建线程的方式有4种，它们分别是：

1、继承Thread类创建线程；

2、实现Runable接口创建线程(首推)；

3、使用Callable和Future创建线程；

4、使用线程池，例如Executor框架。

注意：call()方法有返回值，run()方法没有。

方式1：Thread

public class MyThread extends Thread {

public void run(){

System.out.println("线程");

}

}

public class MainTest {

public static void main(String[] args){

new MyThread().start();

}

}

方式2：Runnable

public class MyThread implements Runnable {

public void run(){

System.out.println("线程Runnable");

}

}

public class MainTest {

public static void main(String[] args){

MyThread myThread = new MyThread();

Thread thread = new Thread(myThread);

thread.start();

}

}

或者直接写线程的实现

public class MainTest {

public static void main(String[] args){

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("创建线程方式二");

}

}).start();

}

}

方式3：Callable或者Future

public class CallableTest implements Callable {

@Override

public Integer call() throws Exception {

// 计算1-100的和

int sum = 0;

for (int i = 1; i <= 100; i++)

sum += i;

return sum;

}

}

public class MainTest {

public static void main(String[] args) {

CallableTest cd = new CallableTest();

// 使用Callable方式创建线程，需要FutureTask类的支持，用于接收运算结果，可以使用泛型指定返回值的类型

FutureTask result = new FutureTask<>(cd);

new Thread(result).start();

int sum = 0;

// 接收运算结果

// 只有当该线程执行完毕后才会获取到运算结果，等同于闭锁的效果

try {

sum = result.get();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

System.out.println("sum is " + sum);

}

}

方式4：Executor框架

Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等

ExecutorService的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown()方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务，当素有已经提交了的任务执行完后，便到达终止状态。

Executors提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口

1、创建固定数目线程的线程池

public static ExecutorService newFixedThreadPool(int nThreads)

2、创建可缓存的线程池

public static ExecutorService newCachedThreadPool()

3、创建一个单线程化的Executor

public static ExecutorService newSingleThreadExecutor()

4、创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

Executor执行Runable任务示例：

public class MainTest {

public static void main(String[] args) {

ExecutorService executorService = Executors.newCachedThreadPool();

// ExecutorService executorService = Executors.newFixedThreadPool(5);

// ExecutorService executorService = Executors.newSingleThreadExecutor();

for (int i = 0; i < 5; i++){

executorService.execute(new TestRunnable());

System.out.println("************* a" + i + " *************");

}

executorService.shutdown();

}

}

class TestRunnable implements Runnable{

public void run(){

System.out.println(Thread.currentThread().getName() + "线程被调用了。");

}

}

public class MainTest {

private ExecutorService pool;

@PostConstruct

public void init(){

//自定义线程工厂

pool = new ThreadPoolExecutor(5, 10, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(20),

new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

//线程命名

Thread th = new Thread(r,"threadPool"+r.hashCode());

return th;

}

},new ThreadPoolExecutor.CallerRunsPolicy());

}

public void test(){

pool.execute(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "线程被调用了。");

}

});

}

}

Executor实现Callable任务示例：

public class MainTest {

public static void main(String[] args){

ExecutorService executorService = Executors.newCachedThreadPool();

List> resultList = new ArrayList>();

//创建10个任务并执行

for (int i = 0; i < 10; i++){

//使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中

Future future = executorService.submit(new TaskWithResult(i));

//将任务执行结果存储到List中

resultList.add(future);

}

//遍历任务的结果

for (Future fs : resultList){

try{

while(!fs.isDone());//Future返回如果没有完成，则一直循环等待，直到Future返回完成

System.out.println(fs.get()); //打印各个线程(任务)执行的结果

}catch(InterruptedException e){

e.printStackTrace();

}catch(ExecutionException e){

e.printStackTrace();

}finally{

//启动一次顺序关闭，执行以前提交的任务，但不接受新任务

executorService.shutdown();

}

}

}

}

class TaskWithResult implements Callable{

private int id;

public TaskWithResult(int id){

this.id = id;

}

/**

* 任务的具体过程，一旦任务传给ExecutorService的submit方法，

* 则该方法自动在一个线程上执行

*/

public String call() throws Exception {

System.out.println("call()方法被自动调用！！！ " + Thread.currentThread().getName());

//该返回结果将被Future的get方法得到

return "call()方法被自动调用，任务返回的结果是：" + id + " " + Thread.currentThread().getName();

}

}

自定义线程池

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池，用该类很容易实现自定义的线程池

public class MainTest {

public static void main(String[] args){

//创建等待队列

BlockingQueue bqueue = new ArrayBlockingQueue(20);

//创建线程池，池中保存的线程数为3，允许的最大线程数为5

ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);

//创建七个任务

Runnable t1 = new MyThread1();

Runnable t2 = new MyThread1();

Runnable t3 = new MyThread1();

Runnable t4 = new MyThread1();

Runnable t5 = new MyThread1();

Runnable t6 = new MyThread1();

Runnable t7 = new MyThread1();

//每个任务会在一个线程上执行

pool.execute(t1);

pool.execute(t2);

pool.execute(t3);

pool.execute(t4);

pool.execute(t5);

pool.execute(t6);

pool.execute(t7);

//关闭线程池

pool.shutdown();

}

}

class MyThread1 implements Runnable{

@Override

public void run(){

System.out.println(Thread.currentThread().getName() + "正在执行。。。");

try{

Thread.sleep(100);

}catch(InterruptedException e){

e.printStackTrace();

}

}

}