Java基础进阶多线程-四种创建方式

1、分析以下程序，有几个线程，除垃圾回收线程之外。有几个线程？

1个线程。（因为程序只有1个栈。）
一个栈中，自上而下的顺序依次逐行执行！

内存图分析：

示例代码01：

public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    private static void m3() {
        System.out.println("m3 execute!");
    }
}
运行结果：
main begin
m1 begin
m2 begin
m3 execute!
m2 over
m1 over
main over
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

2、线程创建的第一种方式：（继承Thread类）

编写一个类，直接继承java.lang.Thread，重写run方法。

怎么创建线程对象？ new就行了。
怎么启动线程呢？ 调用线程对象的start()方法。

run()方法的作用是：

• 调用run方法不会开启分支线程，不会开辟新的分配栈（相当于单线程）

start()方法的作用是：

• 启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。

• 调用start方法开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功

• 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。

• run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
  
  
  

示例代码02:

public class ThreadTest02 {
    public static void main(String[] args) {

        // 这里是main方法，这里的代码属于主线程，在主栈中运行。
        //创建分支线程对象
        MyThread myThread = new MyThread();

        //开启分支线程
        // 启动线程
        //myThread.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        // start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
        // 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        // 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        // run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        myThread.start();//立马结束，开始执行线程内容

        //运行主线程// 这里的代码还是运行在主线程中。
        for(int i=0;i<100;i++){
            System.out.println("主线程： " + i);
        }
    }
}

class MyThread extends Thread {

    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
            for(int i=0;i<100;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

运行结果：

3、线程创建的第二种方式：（Runnable接口）

• 编写一个类，实现java.lang.Runnable接口，实现run方法。

• 采用匿名内部类的方式创建多线程，创建线程对象，以匿名内部类的方式创建多线程

示例代码03：

public class ThreadTest03 {

    public static void main(String[] args) {

        //创建MyRunnable对象// 创建一个可运行的对象
        //MyRunnable m = new MyRunnable();

        //创建线程类，把MyRunnable类传到Thread类的构造器中// 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(m);

        //合并代码
        Thread t = new Thread(new MyRunnable());

        //启动线程
        t.start();

        //执行主线程任务
        for(int i=0;i<100;i++){
            System.out.println("主线程： " + i);
        }

    }
}

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<100;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

运行结果：

示例代码04：

/*
* 采用匿名内部类的方式创建多线程
* */
public class ThreadTest04 {
    public static void main(String[] args) {

        //创建线程对象，以匿名内部类的方式创建多线程
        // 这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                //执行分支线程任务
                for(int i=0;i<100;i++){
                    System.out.println("分支线程： " + i);
                }
            }
        });

        //启动线程
        t.start();

        //执行主线程任务
        for(int i=0;i<100;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

运行结果：

4、线程创建的第三种方式：（callable接口）

• 实现Callable接口
• 这种方式的优点：可以获取到线程的执行结果。
• 这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

示例代码：

public class ThreadTest15 {
    public static void main(String[] args) {

        //创建一个”未来任务类对象“
        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask f = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {// call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method over!");
                int a = 30;
                int b = 20;
                return a - b;//自动装箱(300结果变成Integer)
            }
        });

        //创建线程对象
        Thread t = new Thread(f);

        //启动线程
        t.start();

        //获取分支线程的名字
        Object name = null;
        try {
            // 这里是main方法，这是在主线程中。
            // 在主线程中，怎么获取t线程的返回结果？
            // get()方法的执行会导致“当前线程阻塞”
            name = f.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(name);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("HelloWorld!");
    }
}
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

运行结果：

5、线程创建的第四种方式（线程池）：

JDK5.0 新增线程创建方式，使用线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。

• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。

• 好处：提高响应速度（减少了创建新线程的时间）

• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

• 便于线程管理

  • corePoolSize：核心池的大小
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池相关API

• JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

  • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
  • Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
  • void shutdown() ：关闭连接池