Java多线程-线程创建的3种方式

方式1 继承Thread类(重点)

Thread源码也是实现Runable接口

主要有以下步骤

1 继承Thread类

2 重写run方法,在run方法中编写线程执行代码

3 创建线程对象,调用它的start方法去启动线程

4 总结: 线程开启不一定立刻执行,是由CPU调度安排,每次执行结果都不一样.他们是交替同时执行的

package com.wyh.thread;

/**
 * @program: Thread
 * @description: 多线程测试
 * @author: 魏一鹤
 * @createDate: 2021-12-23 23:37
 **/

//创建线程的方式1:继承Thread类 重写它的Run方法,调用start调用线程
public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我是run方法 = " + i);
        }
    }
    public static void main(String[] args){
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用它的start方法去开启线程
        //start方法才是开启线程  run方法知识去执行线程中的代码
        testThread1.start();
        //testThread1.run();
        //main方法 主线程
        for (int i = 0; i < 2000; i++) {
            System.out.println("我是main方法 = " + i);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

方式2 实现Runnable接口(重点)

主要有以下步骤

1 实现runnable接口

2 实现run方法,编写线程代码

3 新创建线程对象,调用start方法去启动线程

package com.wyh.thread;

/**
 * @program: Thread
 * @description: 实现runnable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-24 23:59
 **/

//创建线程方式2 实现runnable接口，重写run方法 ,执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread2  implements  Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("我是run方法 = " + i);
        }
    }
    public static void main(String[] args){
        //创建runnable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
        //创建线程,通过线程对象开启线程 代理
        Thread thread=new Thread(testThread2);
        //调用start方法
        thread.start();
        //也可以简写为以下格式
       // new Thread(testThread2).start();
        //main方法 主线程
        for (int i = 0; i < 2000; i++) {
            System.out.println("我是main方法 = " + i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

方式3 实现Callable接口(了解)

主要有以下步骤

1 实现callable接口,需要返回值类型

2 重写call方法,需要抛出异常

3 创建目标对象

4 开启服务(创建执行服务)

5 提交执行

6 获取结果

7 关闭服务

///单个线程
package com.wyh.thread;

import java.util.concurrent.*;

/**
 * @program: Thread
 * @description: 实现callable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-26 23:40
 **/

public class TestThread5 implements Callable<Object> {
    //实现callable需要重写它的call方法
    @Override
        public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习"+i);
        }
        return null;
    }
    public static void main(String[] args) throws Exception {
        //线程体 实现类对象
        TestThread5 testThread5 = new TestThread5();
        //创建执行服务                              创建线程池    需要几个线程就写几个
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Object> submit = executorService.submit(testThread5);
        //获取结果
        Object o = submit.get();
        //打印返回结果
        System.out.println(o);
        //关闭服务
        executorService.shutdown();
        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在划水"+i);
        }
    }
}

///多个线程

package com.wyh.thread;

import java.util.concurrent.*;

/**
 * @program: Thread
 * @description: 实现callable接口
 * @author: 魏一鹤
 * @createDate: 2021-12-26 23:40
 **/

public class TestThread5 implements Callable<Object> {
    //实现callable需要重写它的call方法
    @Override
        public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习"+i);
        }
        return null;
    }
    public static void main(String[] args) throws Exception {
        //线程体 实现类对象
        TestThread5 testThread1 = new TestThread5();
        TestThread5 testThread2 = new TestThread5();
        TestThread5 testThread3 = new TestThread5();
        //创建执行服务                              创建线程池    需要几个线程就写几个
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Object> submit1 = executorService.submit(testThread1);
        Future<Object> submit2 = executorService.submit(testThread2);
        Future<Object> submit3 = executorService.submit(testThread3);
        //获取结果
        Object o1 = submit1.get();
        Object o2 = submit2.get();
        Object o3 = submit2.get();
        //打印返回结果
        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
        //关闭服务
        executorService.shutdown();
        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在划水"+i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

实现callable接口的特点

优点

可以自定义返回值

可以抛出异常

缺点

代码稍微复杂一些

start()方法和run()方法的区别

start方法是启动线程,run方法只是去执行线程的代码