Java之线程详解（一）——线程概念知识、创建线程的几种方式

一、线程概念知识

1. 进程与线程的概念

（1）进程：cpu从硬盘中读取一段程序到内存中，该执行程序的实例就叫做进程；一个程序如果被cpu多次被读取到内存中，则变成多个独立的进程。
（2）线程：线程是程序执行的最小单位，在一个进程中可以有多个不同的线程同时执行。

2. 使用多线程一定提高效率吗？

不一定，线程不是越多越好，需要恰到好处。根据CPU实际能开多少线程来确定。
单核的CPU上每次只能够执行一次线程，如果在单核的cpu上开启了多线程，则是对每个线程轮流执行 。 先把上一个线程任务的 CPU上下文（也就是 CPU寄存器和程序计数器）保存起来，加载另一个新的线程任务的上下文到这些寄存器和程序计数器，再跳转到程序计数器所指的新位置，运行新线程任务。
线程等待cpu调度的时候，该线程的状态是为就绪状态，被cpu调度则该线程的状态为运行状态。
程序计数器是用于存放下一条指令所在单元的地址的地方。

3. 同步与异步的区别

（1）同步概念：就是代码从上向下串行执行。
（2）异步的概念：单独分支执行，相互之间没有任何影响。

4. CPU密集型 / IO密集型

CPU密集型：指长时间占用CPU资源，例如： 视频剪辑。
IO密集型：CPU计算时间短，访问外接设备时间长。例如：Input / output。

5. CPU调度算法原理

• 先来先服务：缺点是如果最先来执行的线程是CPU密集型，这样话可能会一直无法继续执行其他的线程。
• 最短作业法： 谁的计算时间短，谁先来执行。
• 优先级调度算法：根据重要性将进程分成4个优先级：
  （1）优先级4 进程D负责画面
  （2）优先级3 进程B和进程C接受用户的指令（重要）
  （3）优先级2 后台处理器（次要）
  （4）优先级1

6. 多线程的应用场景

（1）将执行比较耗时的代码改用多线程异步执行； 可以提高接口的响应速度；
（2）多线程下载任务；
（3）程序异步发送短信/发送邮件；
（4）异步写入日志，日志框架底层；
（5）客户端（APP、微信小程序等）开发。

二、创建线程的几种方法

1. 继承Thread类创建线程
   eg:

public class Thread01 extends Thread {
    @Override
    public void run() {
        System.out.println("thread01线程开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //此处为执行业务代码

        System.out.println("thread01线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread01 thread01 = new Thread01();
        thread01.start();
        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 实现Runnable接口创建线程
   eg:

 public class Thread02 implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread线程开始");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //此处为业务代码

        System.out.println("Thread线程结束");
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        new Thread(new Thread02()).start();
        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 使用匿名内部类的形式创建线程
   eg：

 public class Thread03 {
    public static void main(String[] args) {
        System.out.println("主线程开始");
        //匿名内部类形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread线程开始");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //此处为业务代码
                System.out.println("Thread线程结束");
            }
        }).start();

        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4. 使用lambda表达式创建线程
   eg：

public class Thread04 {
    public static void main(String[] args) {
        System.out.println("主线程开始");
        new Thread(() -> {
            System.out.println("子线程开始");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //此处为业务代码
            System.out.println("子线程结束");
        }).start();
        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5. 使用Callable和Future创建线程
   eg：

public class Thread05 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程");
        Thread.sleep(3000);
        //此处为业务代码
        return 123;
    }
}
1
2
3
4
5
6
7
8
9

public class Test05 {
    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread05 thread05 = new Thread05();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(thread05);
        new Thread(integerFutureTask).start();
        Integer result = null;
        try {
            result = integerFutureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("线程返回结果："+result);
        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6. 使用线程池例如用Executor框架

public class Test06 {
    public static void main(String[] args) {
        System.out.println("主线程开始");
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程开始");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程结束");
            }
        });
        System.out.println("主线程结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7. spring @Async异步注解 结合线程池
   eg：

@Component
Public class ThreadTest {
	@Async
	public void asyncTest(){
		System.out.println("线程开始");
		try {
			Thread.sleep(3000);
		} catch (Exception e) {
            e.printStackTrace();
        }
		System.out.println("线程结束");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13