线程基础
概念
-
程序
程序是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
-
进程
1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程 : 有它自身的产生、存在和消亡的过程 -
线程
1.线程由进程创建的，是进程的一个实体
2.一个进程可以拥有多个线程
-
其他
1、单线程：同一时刻只允许执行一个线程
2、多线程：同一时刻可以执行多个线程
3、并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说,单核cpu实现的多任务就是并发。
4、并行:同一个时刻,多个任务同时执行。多核cpu可以实现并行。
线程的基本使用
- 创建线程的两种方式：
- 继承Thread类，重写run方法
- 实现Runnable接口，重写run方法
继承Thread类
//创建 Cat 对象， 可以当做线程使用
Cat cat = new Cat();
//老韩读源码
/*
(1)
public synchronized void start() {
start0();
}
(2)
//start0() 是本地方法， 是 JVM 调用, 底层是 c/c++实现
//真正实现多线程的效果， 是 start0(), 而不是 run
private native void start0();
*/
cat.start();//启动线程-> 最终会执行 cat 的 run 方法
//cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程， 就会把 run 方法执行完毕， 才向下执行
//说明: 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
//这时 主线程和子线程是交替执行..
System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 main
for(int i = 0; i < 60; i++) {
System.out.println("主线程 i=" + i);
//让主线程休眠
Thread.sleep(1000);
}
}
//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法， 写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() {//重写 run 方法， 写上自己的业务逻辑
while (true) {
//该线程每隔 1 秒。 在控制台输出 “喵喵, 我是小猫咪”
System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
//让该线程休眠 1 秒 ctrl+alt+t
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times == 80) {
break;//当 times 到 80, 退出 while, 这时线程也就退出..
}
}
}
}
进程启动步骤：
- 启动进程，会启动一个main线程
- 主线程又开启一个子线程，主线程不会阻塞（不会等待子线程执行完再执行其他的线程），会继续执行（如果有其他的线程，还是会继续执行），子线程还可以一直开子线程。
- 主线程结束，整个进程不一定结束。当所有的线程结束之后，进程才会结束
启动线程为什么调用start方法而不是run方法？
启动线程需要执行cat.start()，最终会执行cat 的run方法。但是不能直接执行cat的run方法，因为cat的run方法就是一个普通的方法，没有真正启动一个线程，就会把run方法执行完毕才会往下执行，相当于是一个串行执行，无法实现并发执行。执行完毕之后，其他线程才能执行。
实现Runnable接口
- java是单继承的，在某些情况下一个类可能已经继承了某个父类，就不可能再继承Thread类创建线程了
- 此时就可以继承并实现Runnable接口
实现步骤：
-
继承Runnable接口，重写run方法
-
实例化类，用类的实例做参数，实例化Thread对象
-
调用Thread的start方法（底层使用了设计模式，代理模式）
调用start（）===> 调用start0（） ===> 调用run（）
Dog dog = new Dog();
//dog.start(); 这里不能调用 start
//创建了 Thread 对象， 把 dog 对象(实现 Runnable),放入 Thread
Thread thread = new Thread(dog);
thread.start();
c
lass Dog implements Runnable { //通过实现 Runnable 接口， 开发线程
int count = 0;
@Override
public void run() { //普通方法
while (true) {
System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
//休眠 1 秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} if
(count == 10) {
break;
}
}
多线程执行
1、从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
2、实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制,建议使用Runnable
线程终止
- 线程任务结束之后自动退出
- 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
public static void main(String[] args) {
T t = new T();
t.start();
System.out.println("10s后停止。。。。");
try {
Thread.sleep(10*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//主线程休眠10s后对loop进行设置，false时循环退出
t.setLoop(false);
}
class T extends Thread{
private int count = 0;
private boolean loop = true;
@Override
public void run() {
//使用loop代替ture，并提供loop 的set方法
while (loop){
System.out.println("线程运行中。。。" + (++count));
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
线程常用方法
第一组：
- setName //设置线程名称，使之与参数name相同
- getName //返回该线程的名称
- start //使该线程开始执行;Java虚拟机底层调用该线程的 start0方法
- run//调用线程对象run方法
- setPriority //更改线程的优先级
- getPriority //获取线程的优先级
- .sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行)
- interrupt //中断线程
注意事项和细节：
- start底层会创建新的线程，调用run,run就是一个简单的方法调用，不会启动新线程
- 线程优先级的范围
- interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
- sleep:线程的静态方法，使当前线程休眠
第二组：
- yield:线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功（资源紧张的时候礼让成功概率更高）
- join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
案例:main线程创建一个子线程,每隔1s输出hello,输出20次,主线程每隔1秒，输出hi,输出20次.要求:两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，
线程常用方法：
-
用户线程和守护线程
- 用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
- 守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
- 常见的守护线程:垃圾回收机制
-
如何将一个线程设置成守护线程
如果我们希望当main线程结束后，子线程自动结束，可以将子线程设置为守护线程
MyDaemonThread.setDaemon(true); //将子线程设置为守护线程
线程的生命周期
-
JDK中用Thread.State枚举表示了线程的几种状态
-
New：尚未启动的线程处于此状态
-
Runnable：在Java虚拟机中执行的线程处于此状态
Runnable可以再分为两个：
Ready：
Running：
-
Blocked：被阻塞等待监视器锁定的线程处于此状态
-
Waiting：正在等待另一个线程执行特定动作的线程处于此状态
-
Timed_Waiting：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态（调用sleep会处在此状态）
-
Terminated：已退出的线程处于此状态
-
线程的同步
-
线程同步机制
- 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
- 也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
-
同步具体方法-Synchronized
-
同步代码块
synchronized (对象){ //得到对象的锁才能同步代码 //需要被同步的代码 } -
synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m(String name){ //需要被同步的代码 }
-
-
同步原理分析
互斥锁
- Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
- 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
- 同步的局限性:导致程序的执行效率要降低
- 同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)，非静态锁加在对象
- 同步方法(静态的)的锁为当前类本身。静态锁加在类
//非静态方法中的代码块加互斥锁 class A{ public void m(){ synchronized(this){ //code } } } //静态方法中的代码块加互斥锁 class A{ public static void m(){ synchronized(A){ //code } } } //非静态方法加锁 public synchronized void m(){ //此时锁在this对象 } //静态方法加锁 public synchronized static void m(){ //此时锁在类 } -
互斥锁注意事项和细节
- 同步方法如果没有使用static修饰:默认锁对象为this
- 如果方法使用static修饰，默认锁对象:当前类.class
- 实现的落地步骤:
- 需要先分析上锁的代码
- 选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个即可!（如果多个线程，每个线程有个run方法，他们访问的不是同一个run方法，所以锁不住，要设置为静态方法）
线程的死锁
基本介绍：
多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程里一定要避免死锁的发生。
释放锁
下面操作会释放锁：
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前代码在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait（）方法，当前线程暂停并释放锁
下面操作不会释放锁：
-
线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
-
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
