什么是多线程？
程序、进程与线程
程序（Progame）：只是一组指令的有序集合，它本身没有任何运行的含义，它只是一 个静态的实体。
进程（Process） ：程序在某个数据集上的执行。进程是一个动态的实体，它有自己的生命周期。
线程（Thread） ：线程是进程中的一个实体，是CPU调度和分派的基本单位，一个进程可以可以包括多个线程。
多线程的实例
- JAVA程序中的基本线程：
① main()方法是JAVA程序的主进程，所有线程都需要从main()方法进行调用。
② gc()垃圾回收线程，与主线程同时进行，可作为主线程的守护（Daemon ）线程。
③ 异常处理线程，异常会影响主线程。 - 单核CPU：是一种假的多线程，因为频率很高，所以我们感觉不到。本质上在同一时间段内CPU只执行一个操作。
- 在玩网络游戏时，多人同时在线进行游戏也用到了多线程机制。
多线程的优点
- 可以更好的利用cpu的资源，提高CPU的利用率。
- 线程之间可以共享数据。
- 系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；
线程的创建与使用
三种创建方式及调用方式
（1）继承Thread类
- 创建步骤：
- 创建一个继承于Thread类的子类
2. 重写Thread类的run方法–>将此线程执行的操作声明在run()中。
3. 创建子类对象
4. 通过子类对象调用start()方法：
- 代码实现：
package 多线程;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread myThread = new MyThread();
myThread.start();
//new MyThread().start();
}
}
class MyThread extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
//写此线程的实现功能
}
}
（2）实现Runnable接口
- 创建步骤：
- 创建一个实现类实现Runnable接口
2. 重写Thread类的run方法–>将此线程执行的操作声明在run()中。
3. 创建子类对象
4. 通过子类对象调用start()方法：
- 代码实现：
package 多线程;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
//new Thread(myThread).start();
}
}
class MyThread implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
//写此线程的实现功能
}
}
（3）实现Callable接口
- 创建步骤：
1.创建一个实现callable接口的实现类。
2.重写call方法，将此线程需要执行的操作声明在call方法中。
3.创建Callable接口实现类的对象
4.创建服务。
5.提交服务到Future对象。等同于前两种方法的start()方法。
6.//获取返回值,并捕获（抛出）异常。
7.关闭服务。
-代码实现
package 多线程;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// TODO Auto-generated method stub
MyThread myThread = new MyThread();
//创建服务
ExecutorService ser = Executors.newFixedThreadPool(1);
//提交服务
Future<Boolean> t1 = ser.submit(myThread);
//获取返回值
Boolean rt1 = t1.get();
//关闭服务
ser.shutdownNow();
System.out.println(rt1);
}
}
class MyThread implements Callable<Boolean>{
@Override
public Boolean call() {
// TODO Auto-generated method stub
//写此线程的实现功能
return true;
}
}
三种创建方式的比较
| 创建方式 | 返回值 | 能否继承别的类 | 优缺点 |
|---|---|---|---|
| 继承Thread类 | × | 不能 | 操作简单 |
| 实现Runnable接口 | × | 可以 | 能够使多个线程操作统一资源 |
| 实现Callable接口 | √ | 可以 | 可以抛出异常、获取线程运行结果，有返回值 |
多线程的实现原理-------------静态代理设计模式
……案例引入：结婚案例。（真实对象为新人，代理对象为婚庆公司，任务为结婚这件事。）
package 多线程;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建真实对象、
NewMan man = new NewMan("小王");
//创建代理对象。
Wedding wed = new Wedding(man);
//代理对象执行完成任务的方法
wed.GetMarry();
}
}
//要实现的共同接口、要完成的任务。真实对象与代理对象必须实现同一个接口
interface Marry1 {
public abstract void GetMarry();
}
//真实对象。完成这一任务的真实对象。
class NewMan implements Marry1{
protected String name;
public NewMan(String name) {
this.name = name;
}
@Override
public void GetMarry() {
// TODO Auto-generated method stub
System.out.println(name + "要结婚了！");
}
}
//代理对象，真实对象无法做的任务由代理对象完成。
class Wedding implements Marry1{
private NewMan newman;
public Wedding(NewMan newMan) {
this.newman = newMan;
}
@Override
public void GetMarry() {
// TODO Auto-generated method stub
System.out.println("支付预付款，前期准备工作");
newman.GetMarry();
System.out.println("支付尾款，收尾工作");
}
}
- 真实对象与代理对象必须实现同一个接口。即最终任务。
- 代理对象要传入真实对象的引用。
- 通过调用代理对象的方法来完成最终的目的。
与多线程的联系：
········多线程的创建本质上都是实现了Runnable接口，通过传入自定义线程的引用到Thread类的代理对象，调用start()方法开启线程。
Lamda表达式
Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。可以简化代码。
适用范围：函数式接口（只有一个抽象方法的接口，如上例中的Marry1接口、Runnable接口）
格式：（）->{}
- 应用实例：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread t1 = new Thread(()-> {
System.out.println("Lamda表达式");
});
t1.start();
}
}
线程的状态
线程的生命周期及状态监测
线程的生命周期如下图所示
图片来自狂神说
- 新建状态：开始创建线程对象到调用start()方法之前的时间段。
- 就绪状态：线程对象调用start()方法之后进入就绪状态，此时的就绪状态表示此线程已 经做好了准备去接受CPU的调度，而不是已经被CPU调度。
- 运行状态：线程对象被CPU调度执行，线程进入运行状态。就绪状态是线程运行的唯一入口
- 阻塞状态：处于运行状态中的线程由于某种原因终止了CPU的调度，此时线程为阻塞状态。线程进入阻塞状态大致有以下三种原因：
1、等待阻塞：使用wait()方法使线程进入阻塞状态，
2、同步阻塞：线程获取synchronized同步锁失败，线程会进入阻塞状态。
3、其它阻塞：线程调用sleep等方法时，也会使线程进入阻塞状态。 - 死亡状态：线程执行结束或者因为异常而结束run（）方法，线程生命周期结束。
线程的状态改变的常用方法
-
线程休眠—sleep
sleep()方法需要传入一个单位为ms的参数，同时会抛出一个异常。使用此方法必须抛出或者捕获异常。 调用该方法会使线程进入一个短暂的阻塞状态，不会释放对象锁。 可以利用sleep方法对线程进行放大，能够反应出线程的隐性问题。 -
线程礼让—yield
yield()方法可以使线程从运行状态进入就绪状态，交出CPU的控制权 但CPU执行哪个线程随机决定，并不一定会真正做到礼让 礼让机制并不能保证另一个线程一定拿到CPU控制权 -
线程的插队—join
join()方法与yield()方法相同，使线程从运行状态进入就绪状态，会交出CPU的控制权。 不同的是，调用join()方法后，原线程必须等待调用此方法的线程执行结束后才可以继续执行。 -
线程的优先级—setPriority
线程的优先级分为1-10，优先级越高，在同等条件下CPU优先执行的概率会越高，默认优先级为5. setPriority()方法可以改变线程的优先级，传入一个参数来表示优先级即可。 -
守护线程—daemon
JAVA中的线程分为两大类：用户线程（User）与守护线程（Daemon）。 JAVA中的gc（垃圾处理机制）线程便是守护线程。在程序运行过程中，守护线程会一直存在并自动断开。 程序的终止条件为所有的用户线程执行结束，守护线程不会影响程序执行的过程。 守护线程在一定程度上保证了用户线程安全顺利的执行。 使用setDaemon(True)方法将线程设置为守护线程。
*** ***** *** ***** *** ***** *** ***** 总结：* ***** *** ***** *** ***** ***
PS: 这是我的第一篇博文，我也是刚刚开始学习，如有错误之处还望大家多多指出，欢迎大家一起来讨论技术（都看到这里了不帮我点个赞吗~~~）！
#希望能够坚持用博客记录自己的学习心得。大家一起加油！
下一篇：JAVA多线程的同步与通信！
扫一扫
449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
