Java开启线程的四种⽅法
1，继承Thread类
继承Thread类，重写run⽅法(不推荐，因为java的单继承局限性)
1public class ExtendThread extends Thread {
2
3/*
4    * 创建步骤如下：
5    * 1，定义Thread类的⼦类，并重写该类的run()⽅法，该run()⽅法的⽅法体就代表了线程需要完成的任务。因此把run⽅法称为线程执⾏体。
6    * 2，创建Thread⼦类了的实例，即创建线程对象。本实例中是new⼀个ExtendThread，即可创建线程对象，也就是开启了⼀个线程
7    * 3，调⽤线程对象的start()⽅法来启动该线程。
8    *
9    * 调⽤⽰例：
10    * //循环10次即开启10个线程
11    * for (int i = 0; i < 10; i++) {
12    *    ExtendThread extendThread = new ExtendThread();
13    *    extendThread.start();
14    * }
15    * */
16
17/**
18    * 重写Thread类的run()，这个⽅法称为线程执⾏体
19    * */
20    @Override
21public void run() {
22        doSomething();
23    }
24
25/**
26    * 需要处理的任务
27    * */
28public void doSomething(){
29for (int i = 0; i < 10; i++) {
30            System.out.println(Thread.currentThread().getName() + "执⾏" + i);
31        }
32    }
33 }
2，实现Runnable接⼝
⽅式⼀：直接实现Runnable接⼝(避免单继承的局限性,⽅便共享资源，推荐使⽤)
1public class RunnableImpl implements Runnable {
2
3/*
4    * 创建步骤如下：
5    * 1，定义Runnable接⼝的实现类，并且实现run⽅法，这个⽅法同样是线程执⾏体
6    * 2，创建Runnable实现类的实例，并以此实例对象作为Thread的target来创建Thread类，这个新创建的Thread对象才是真正的线程对象，即开启了新的线程
7    * 3，调⽤线程对象的start()⽅法来开启该线程
8    *
9    * 调⽤⽰例：
10    * //开启10个线程
11    * for (int i = 0; i < 10; i++) {
12    *    Thread thread = new Thread(new RunnableImpl());
13    *    thread.start();
14    * }
15    * */
16
17/**
18    * 实现Runnable接⼝的run⽅法，这个⽅法称为线程执⾏体
19    * */
20    @Override
21public void run() {
22        doSomething();
23    }
24
25/**
26    * 需要处理的任务
27    * */
28private void doSomething(){
29for (int i = 0; i < 10; i++) {
30            System.out.println(Thread.currentThread().getName() + "执⾏" + i);
31        }
32    }
33 }
⽅式⼆：匿名内部类
1public class Anonymous {
2
3/*
4    * 创建步骤如下：
5    * 匿名内部类本质上也是⼀个类实现了Runnable接⼝，重写了run⽅法，只不过这个类没有名字，直接作为参数传⼊Thread类
6    *
7    * 调⽤⽰例：
8    * //开启10个线程
9    * for (int i = 0; i < 10; i++) {
10    *    Anonymous anonymous =new Anonymous();
11    *    Run();
12    * }
13    *
14    * */
15
16public void myRun(){
17new Thread(new Runnable() {
18            @Override
19public void run() {
20                doSomething();
21            }
22        }).start();
23    }
24
25/**
26    * 需要处理的任务
27    * */
28private void doSomething(){
29for (int i = 0; i < 10; i++) {
30            System.out.println(Thread.currentThread().getName() + "执⾏" + i);
31        }
32    }
33 }
3，实现Callable接⼝
1public class CallableImpl implements Callable<String> {
2
3/*
4    * 创建步骤如下：
5    * 1，定义实现Callable<V>接⼝的实现类，实现call⽅法，这个⽅法是线程执⾏体java线程池创建的四种
6    * 2，创建Callable<V>实现类的实例，借助FutureTask得到线程执⾏的返回值
7    * 3，将FutureTask的实例，作为Thread的target来创建Thread类
8    * 4，调⽤start⽅法，开启线程
9    *
10    * 调⽤⽰例：
11    * Callable<String> tc = new CallableImpl();
12    * FutureTask<String> task = new FutureTask<>(tc);
13    * new Thread(task).start();
14    * try {
15    *    System.out.());
16    * } catch (InterruptedException | ExecutionException e) {
17    *    e.printStackTrace();
18    * }
19    *
20    * 说明：
21    * 1.与使⽤Runnable相⽐， Callable功能更强⼤些
22    * 2.实现的call()⽅法相⽐run()⽅法，可以返回值
23    * 3.⽅法可以抛出异常
24    * 4.⽀持泛型的返回值
25    * 5.需要借助FutureTask类，⽐如获取返回结果
26    * Future接⼝可以对具体Runnable、Callable任务的执⾏结果进⾏取消、查询是否完成、获取结果等。
27    * FutureTask是Futrue接⼝的唯⼀的实现类
28    * FutureTask 同时实现了Runnable, Future接⼝。它既可以作为Runnable被线程执⾏，⼜可以作为Future得到Callable的返回值
29    *
30    * */
31
32private int ticket = 5;
33
34    @Override
35public String call() throws Exception {
36for (int i = 0; i < 10; i++) {
37            System.out.println(doSomething());
38        }
39
40return "出票任务完成";
41    }
42
43public String doSomething() {
44        String result = "";
45if (this.ticket > 0) {
46            result = "出票成功，ticket=" + this.ticket--;
47        } else {
48            result = "出票失败，ticket=" + this.ticket;
49        }
50return result;
51    }
52 }
4，创建线程池
1public class ThreadPool implements Runnable {
2
3/*
4    * 创建步骤如下：
5    * 1，定义Runnable接⼝的实现类，或者定义（继承Runnable接⼝的类）的实现类，并且实现run⽅法，这个⽅法是线程执⾏体
6    * 2，创建⼀个⾃定义线程个数的线程池
7    * 3，实例化Runnable接⼝的实现类
8    * 4，将3步的实例，作为线程池实例的execute⽅法的command参数，开启线程
9    * 5，关闭线程池
10    *
11    * 调⽤⽰例：
12    * ExecutorService pool = wFixedThreadPool(2);
13    * ThreadPool threadPool = new ThreadPool("AA");
14    * ThreadPool threadPoo2 = new ThreadPool("BB");
15    * ute(threadPool);
16    * ute(threadPoo2);
17    * pool.shutdown();
18    *
19    * 说明：
20    * ⽰例中创建的是2个线程的线程池
21    * execute⽅法是开启线程⽅法，实参要求是实现Runnable的类。所以，继承Thread类的⼦类也可以以线程池的⽅式开启线程
22    *
23    * */
24
25    String name;
26public ThreadPool(String name) {
27this.name = name;
28    }
29
30    @Override
31public void run() {
32        doSomething();
33    }
34
35/**
36    * 需要处理的任务
37    * */
38private void doSomething() {
39for (int i = 0; i < 10; i++) {
40            System.out.println(Thread.currentThread().getName() + "执⾏" + i + "，name=" + this.name);
41        }
42    }
43 }

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。