这篇博客详细介绍了Java线程的基础知识，包括线程的定义、进程的区别，以及线程的创建、终止和常用方法。此外，还深入探讨了线程的生命周期，六种状态及其转换，并重点讲解了线程同步机制Synchronized，包括概念、使用方法和互斥锁，以及如何避免线程死锁。最后，阐述了释放锁的各种情况。
文章目录
一、线程相关概念
程序（program）
是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
进程
1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷配新的内存空间。
2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程
线程
1.线程由进程创建的，是进程的一个实体
2.一个进程可以拥有多个线程
其他相关概念
1.单线程:同一个时刻，只允许执行一个线程
2.多线程:同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时开多个聊天窗口,一个迅雷进程，可以同时下载多个文件
3．并发:同一个时刻,多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
4.并行:同一个时刻，多个任务同时执行。多核cpu可以实现并行。并发和并行可以同时都有
二、线程基本使用
1.创建线程
1.继承Thread类，重写run方法
代码如下（示例）：
public class Thread_01 {
public static void main(String[] args) throws InterruptedException {
// TODO 自动生成的方法存根
Cat cat = new Cat();
//cat.run();这只是一个普通的方法，还是在主线程下执行
cat.start();//启动线程,最终执行Cat的run方法
//说明：当main线程启动一个子线程Thread-0.主线程不会阻塞,继续执行
//主线程挂了，子线程不一定挂，子线程挂了，子线程的子线程不一定挂，可以用jconsole看此程序
//这时，主线程和子线程交替进行
System.out.println("主线程继续执行,主线程名"+Thread.currentThread().getName());
for (int i = 0; i < 5; i++) {
System.out.println("主线程 i="+i);
Thread.sleep(1000);
}
}
}
//一个类基础了Thread类，该类就可以当做线程使用
//重写run方法，写上自己的业务代码
//run Thread类 实现了 Runnable 接口的run 方法
class Cat extends Thread{
int times = 0;
@Override
public void run() {
// TODO 自动生成的方法存根
while(true) {
System.out.println("aaaaaaa"+(++times)+"线程名"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
if (times==5) {
break;
}
}
}
}
源码略讲
1.首先跳到start()方法,调用start0()
(其余代码省略)
public synchronized void start(){
......
start0();
......
}
2.跳到start0();是一个本地方法(native)，是JVM调用，底层是c/c++实现
多线程由start0()实现，调用后线程并不一定立马执行，只是线程变成可运行转态，具体什么时候执行，取决于CPU，由CPU调度（涉及到操作系统）
private native void start0();
2.实现Runnable接口，重写run方法
代码如下（示例）：
public class Thread_02 {
public static void main(String[] args) throws InterruptedException {
// TODO 自动生成的方法存根
Dog dog = new Dog();
//但并没有start();方法
//解决办法，创建Thread对象，把实现了Runnable接口对象放入Thread
//此设计使用了代理模式(静态代理)设计的思想，具体看下面的模拟源码
Thread thread = new Thread(dog);
thread.start();
}
}
class Dog implements Runnable{
int times = 0;
@Override
public void run() {
// TODO 自动生成的方法存根
while(true) {
System.out.println("汪汪"+(++times)+"线程名"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
if (times==10) {
break;
}
}
}
}
模拟源码
//将实现了Runnable接口的对象传入有参构造器，使得target不为空
//再ThreadProxy.start()调用start0();
//start0()此时开启线程,调用run方法
//run方法判断target是否为空,不为空则启用开始传入对象的run方法实现代理效果，启动线程
class ThreadProxy implements Runnable{
Runnable target = null;
@Override
public void run() {
// TODO 自动生成的方法存根
if(target!=null) {
target.run();
}
}
public ThreadProxy(Runnable target){
this.target=target;
}
public void start() {
start0();
}
public void start0() {
run();
}
}
3.二者的区别
1．从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本
质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了
Runnable接口
2．实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了
单继承的限制
Dog dog1 = new Dog();
Thread thread1 = new Thread(dog);
Thread thread2 = new Thread(dog);
thread1.start();
thread2.start();
2.线程终止
1.当线程完成任务后，会自动退出。
2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
public class Thread_Exit {
public static void main(String[] args) throws InterruptedException {
// TODO 自动生成的方法存根
T t1= new T();
new Thread(t1).start();
//如果希望main线程去控制t1线程的终止,通过修改控制变量loop
Thread.sleep(4000);
t1.setLoop(false);
}
}
class T implements Runnable{
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
// TODO 自动生成的方法存根
while(loop) {
System.out.println("汪汪");
try {
Thread.sleep(1000);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}
3.线程常用方法
- setName //设置线程名称,使之与参数name相同
- getName //返回该线程的名称
- start //使该线程开始执行;Java虚拟机底层调用该线程的startO方法
- run //调用线程对象run方法;
- setPriority //更改线程的优先级，优先级有1-10，越大越高
- getPriority //获取线程的优先级
- sleep //静态方法，在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
- interrupt //中断线程，中断线程的休眠
- yield:线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
- join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
案例:创建一个子线程，每隔1s输出hello,输出20次,主线程每隔1秒,输出hi,输出20次.要求:两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，但只能插自己的主线程（上级）的队
4.线程分类
- 用户线程:也叫工作线程，当线程的任务执行完或通知方式结束
- 守护线程:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束，常见的守护线程:垃圾回收机制
//设置守护线程，先设置再启动
//1
T1 t1= new T1();//T1继承Thread类
t1.setDaemon(true);
//2
T1 t1= new T1();//T2实现Runnable接口
Thread thread = new Thread(t1);
thread.setDaemon(true);
三、线程生命周期
1.六种状态
- new:尚未启动的线程处于此状态。
- Runnable:在Java虚拟机中执行的线程处于此状态。(下图的大框，具体内容属于内核，操作系统)
- TimedWaiting:正在等待另一个线程执行动作达到指定等待时间的线程处于此状态.
- Waiting:正在等待另一个线程执行特定动作的线程处于此状态。
- Blocked:被阻塞等待监视器锁定的线程处于此状态。
- Teminated:已退出的线程处于此状态。
2.状态转换图
四、线程同步机制(Synchronized)
概念
- 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技
术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。 - 也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不
可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作.
·
使用方法
1.同步代码块
/*synchronized(对象) {
synchronized相当于一把锁，得到锁，才能操作同步代码
}
*/
public void method()
{
synchronized(this) {
//需要同步(上锁)的代码
//同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
}
synchronized(类名.class) {
//需要同步(上锁)的代码
//同步方法(静态的)的锁为当前类本身
}
}
2.放在方法声明中，使方法为同步方法
public synchronized void method()
{
//需要同步(上锁)的代码
//同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
}
//静态
public synchronized static void method()
{
//需要同步(上锁)的代码
//同步方法(静态的)的锁为当前类本身
}
互斥锁
- Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
- 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻,只.能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
- 同步的局限性:导致程序的执行效率要降低
- 同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)，默认为this
- 同步方法(静态的)的锁为当前类本身。
线程的死锁
基本介绍
多个线程都占用了对方的锁资源,但不肯相让，导致了死锁,在编程是一定要避免死锁的发生.
代码如下（示例）：
//构造一个死锁
public class DeadLock_ {
public static void main(String[] args) {
// TODO 自动生成的方法存根
DeadLockDemo A = new DeadLockDemo(true);
DeadLockDemo B = new DeadLockDemo(false);
A.start();
B.start();
}
}
class DeadLockDemo extends Thread{
static Object o1Object = new Object();
static Object o2Object = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {
// TODO 自动生成的构造函数存根
this.flag=flag;
}
@Override
public void run() {
// TODO 自动生成的方法存根
//1.如果flag为T，线程A就会先得到/持有o1Object对象锁，然后尝试去获取o2Object对象锁
//2.如果线程A得不到o2Object对象锁,就会Blocked
//3.如果flag 为 F，线程B就会先得到/持有o2Object对象锁，然后尝试去获取o1Object对象锁
//4。如果线程B得不到o1Object对象锁,就会Blocked
if (flag) {
synchronized (o1Object) {
System.out.println(Thread.currentThread().getName()+"进入1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
synchronized (o2Object) {
System.out.println(Thread.currentThread().getName()+"进入2");
}
}
} else {
synchronized (o2Object) {
System.out.println(Thread.currentThread().getName()+"进入3");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
synchronized (o1Object) {
System.out.println(Thread.currentThread().getName()+"进入4");
}
}
}
}
}
释放锁
1.当前线程的同步方法、同步代码块执行结束
案例:上厕所，完事出来
2.当前线程在同步代码块、同步方法中遇到break、return
案例:没有正常的完事,经理叫他修改bug，不得已出来
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
案例:没有正常的完事,发现忘带纸,不得已出来
4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
案例:没有正常完事,觉得需要酝酿下,所以出来等会再进去
下面操作不会释放锁
1．线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方
法暂停当前线程的执行,不会释放锁
案例:上厕所，太困了，在坑位上眯了一会
2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起,
该线程不会释放锁。
提示;应尽量避免使用suspend()和resume()来控制线程,不推荐使用
扫一扫
2235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
