浅谈对多线程的理解（一）

今天咱们先来聊聊有关线程的话题......

 

一. 线程概述

1. 简单区分程序、进程和线程

程序是指一段静态的代码

进程是指正在执行的程序，将静态的代码运行起来

线程是指正在执行程序的小单元

举个栗子，班级准备大扫除，在大扫除以前，老师在纸上列了一个清单，每一个同窗都有不一样的工做任务，分配好任务以后，每一个同窗都是有条不紊地完成本身的任务，扫地的同窗去扫地，擦黑板的同窗去擦黑板，清理桌子的同窗清理桌子......在这个例子里，这个清单就是程序，而这个班级的全体同窗是一个总体，也就是一个进程，最后，这个班级里面一个个同窗就是一个个线程。

---

2. 理解进程

理解线程以前，先简单理解一下进程。进程的三大特征：独立性、动态性、并发性。

独立性：指进程是系统中独立存在的实体，拥有独立的资源（eg：私有的地址空间）。

动态性：这是相对于程序而言的，程序是一段静态的代码，而进程是活动的，拥有本身的生命周期。

并发性：多个进程能够在单个处理器上并发执行，互不影响。

仍是上面那栗子，这个班级就是一个进程，他是一个总体，他拥有本身的教室，有本身的班级名字，这里能够体现出独立性。这个班级的全体人员按照的任务清单干活，直至把教室打扫干净（即完成任务），这里能够体现出动态性。并发性呢，首先这个班级不仅有一个，还有好多其余的班级，他们也能够打扫他们本身的教室，互不影响。

---

3. 理解线程

线程是进程的执行单元，在程序中，线程是独立的、并发的执行流。

线程的特色：

1. 每一个线程有本身的堆栈，本身程序计数器，本身的局部变量，这里体现了线程的独立性。

2. 相同父进程下的全部线程共享进程独立的内存单元（eg：代码段、进程的共有数据），为此能够实现线程间的相互通讯。

3. 多个线程之间也能够并发执行，互不影响。

---

4. 多线程 VS 多进程

1. 线程之间能够共享内存，而进程之间不能够。

2. 系统建立线程代价比较小，并且多线程是实现多任务并发比多进程的效率更高。

3. Java语言内置了多线程功能，简化了Java多线程编程。

---

二. 线程的建立和启动

1. 继承Thread类建立线程类

步骤：

1. 定义一个线程类，需继承Thread类。

2. 重写父类的run( )方法,此方法是线程执行体，供cpu自动调用（cpu会用调度策略去处理就绪状态的线程）。

3. 建立线程类的实例对象，调用start( )方法，这个方法告诉cpu这个线程对象进入就绪状态。

 1 package com.hx.thread;
 2 ​
 3 // 1.定义一个线程类，需继承Thread类。
 4 public class MyThread1 extends Thread {
 5     // 2.重写run方法
 6     public void run() {
 7         for (int i = 0; i < 100; i++) {
 8             System.out.println(Thread.currentThread().getName() + " " + i);
 9             try {
10                 Thread.sleep(10);
11             } catch (Exception e) {
12                 e.printStackTrace();
13             }
14         }
15     }
16     
17     public static void main(String[] args) throws Exception {
18         // 3.建立线程实例，调用start方法，进入就绪状态，交给cpu
19         MyThread1 myThread1 = new MyThread1();
20         myThread1.start();
21         for (int i = 0; i < 100; i++) {
22             System.out.println(Thread.currentThread().getName() + "     " + i);
23             Thread.sleep(10);
24         }
25     }
26 }

---

2. 实现Runnable接口建立线程类

步骤：

1. 定义一个线程类，需实现Runnable接口。

2. 实现接口的run( )方法,此方法是线程执行体，供cpu自动调用（cpu会用调度策略去处理就绪状态的线程）。

3. 建立线程类的实例对象。但是Runnable没有start( )方法，所以须要第4步。

4. 建立一个Thread对象（真正的线程对象），用来包装上面的那个实例对象，而后调用start( )方法。

 1 package com.hx.thread;
 2 ​
 3 // 1.定义一个线程类，需实现Runnable接口。
 4 public class MyThread2 implements Runnable {
 5     // 2.实现接口的run( )方法
 6     @Override
 7     public void run() {
 8         for (int i = 0; i < 100; i++) {
 9             System.out.println(Thread.currentThread().getName() + " " + i);
10             try {
11                 Thread.sleep(10);
12             } catch (Exception e) {
13                 e.printStackTrace();
14             }
15         }
16     }
17 ​
18     public static void main(String[] args) throws Exception {
19         // 3.建立线程类的实例对象
20         MyThread2 myThread2 = new MyThread2();
21         // 4.建立一个Thread对象（真正的线程对象），用来包装上面的那个实例对象，而后调用start( )方法。
22         Thread t = new Thread(myThread2);
23         t.start();
24         for (int i = 0; i < 100; i++) {
25             System.out.println(Thread.currentThread().getName() + "     " + i);
26             Thread.sleep(10);
27         }
28     }
29 }

---

3. 实现Callable接口建立线程类

步骤：

1. 定义一个线程类，需实现Callable接口。

2. 实现Callable接口的call( )方法，此方法是线程执行体。

3. 建立线程类的实例对象。

4. 建立FutureTask的对象来包装线程类实例对象。

5. 建立Thread的对象来包装Future类的实例对象。

 1 package com.hx.thread;
 2 import java.util.concurrent.Callable;
 3 import java.util.concurrent.FutureTask;
 4 ​
 5 // 1.定义一个线程类，需实现Callable接口
 6 public class MyThread3 implements Callable {
 7     // 2.实现Callable接口的call()方法
 8     @Override
 9     public String call() throws Exception {
10         for (int i = 0; i < 100; i++) {
11             System.out.println(Thread.currentThread().getName() + " " + i);
12             Thread.sleep(10);
13         }
14         return Thread.currentThread().getName();
15     }
16 ​
17     public static void main(String[] args) throws Exception {
18         // 3.建立线程类的实例对象
19         MyThread3 myThread3 = new MyThread3();
20         // 4.建立FutureTask的实例对象来包装线程类实例对象
21         FutureTask futureTask = new FutureTask(myThread3);
22         // 5.建立Thread的实例对象来包装Future类的实例对象
23         Thread t = new Thread(futureTask);
24         t.start();
25         for (int i = 0; i < 100; i++) {
26             System.out.println(Thread.currentThread().getName() + "     " + i);
27             Thread.sleep(10);
28         }
29         // 打印出call()方法的返回值
30         System.out.println(futureTask.get());
31     }
32 }

---

4. 三种方式的对比

1. 采用继承Thread类这种方式来建立线程，编写简单，但是因为Java不支持多继承，因此不能再继承其余父类。

2. 采用实现Runnable接口或Callable接口，能够继承其余类，多个线程能够共享同一个target对象，很是适合多个线程来处理同一资源的状况，能够更好地体现面向对象的特色，不过编写比较复杂。

3. 采用实现Callable接口，call( )方法是线程执行体，有返回值，能够抛出异常，其功能比run( )方法更强大。

---

三. 线程的生命周期

---

四. 控制线程

Thread类的工具方法

join( )：让一个线程等待另一个线程完成的方法，当在某个程序执行流中调用其余线程的join方法，调用线程将被阻塞，直至join线程完成。

setDaemon(true)：指定线程设置为后台线程。在start( )以前调用。后台线程，又称守护线程、精灵线程，其做用是为其余线程提供服务（eg：JVM的垃圾回收线程），若是全部的前台线程都死亡，后台线程也会自动死亡。

sleep( long time)：设置线程睡眠时间，参数单位为毫秒，调用此方法线程进入阻塞状态。

setPriority(int newPriority)：设置优先级，参数范围：1-10，通常使用三个静态常量（MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY）。

---

 

嘻嘻，今天的内容就先到这吧，欢迎你们前来留言。

因为如今我的水平有限，文章若存不当之处，还请各位大佬们加以斧正。