本文深入探讨Java多线程的基本概念，包括程序、进程与线程的区别，详细讲解线程的创建、生命周期、同步机制及线程通信。通过具体代码示例，解析线程的同步锁、死锁问题及解决策略。
一、基本概念：程序 - 进程 - 线程
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程，就是支持多线程的
类似于CPU的核数
多线程的创建和启动
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。
Thread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来调用这个线程
Thread类
构造方法
Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象
创建线程的两种方式
继承Thread类
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象，即创建了线程对象。
- 调用线程对象start方法：启动线程，调用run方法。
实现Runnable接口
1）定义子类，实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给
Thread类的构造方法中。
5）调用Thread类的start方法：开启线程，调用
Runnable子类接口的run方法。
public class Thread extends Object implements Runnable
public class Test {
public static void main(String[] args) {
// Thread t0 = new TestThread();//继承Thread类的线程
// t0.start();//启动线程,开始运行run方法中的代码
//
// Thread t1 = new TestThread();
// t1.start();
// Thread t2 = new TestThread();
// t2.start();
// Thread t3 = new Thread(new TestRunnable());
// t3.start();
// Thread t4 = new Thread(new TestRunnable(), "t-1");
// t4.start();
// Thread t5 = new Thread(new TestRunnable(), "t-2");
// t5.start();
Runnable run = new TestRunnable();
Thread t4 = new Thread(run, "t-1");
t4.start();
Thread t5 = new Thread(run, "t-2");
t5.start();
// new Test().test();
System.out.println("---------------1");
System.out.println("---------------2");
System.out.println("---------------3");
/**
* 多次运行这个main方法之后
* 我们发现main方法中打印的3行与开启线程运行run方法中的打印语句是混合起来
* 而且main方法中的打印与run方法中打印语句顺序是不固定的
* 为什么呢？
* main执行t0.start()方法开启多线程之后，就相当于在main方法之外开启一个支流
* 这个个时候t0.start()的之后的main方法的其他代码的运行就与run方法运行无关了
* 以当前代码为例
* t0.start()的之后的main方法的其他代码与run方法的代码并行运行
* 就像两条河流一样，各走各的
* 那么控制台输出的结果就是两条并行程序的运行结果总和，这个结果需要拆开成两部分看
* 就可以看到，各自是保持自己输出顺序
* 这个就是多线程的异步,这个异步相对于执行t0.start()的主程序来说的
* 简单来说开启了线程之后run方法中运行的代码主程序中t0.start()之后的程序是并行执行的，没先后关系，这个叫异步
*/
}
public void test(){
System.out.println("多线程运行的代码");
for(int i = 0; i < 5; i++){
System.out.println("这是多线程的逻辑代码:" + i);
}
}
区别**
继承Thread: 线程代码存放Thread子类run方法中。重写run方法
public class TestThread extends Thread{
@Override
public void run() {
System.out.println("多线程运行的代码");
for(int i = 0; i < 5; i++){
System.out.println("这是多线程的逻辑代码:" + i);
}
}
}
实现Runnable：线程代码存在接口的子类的run方法。实现run方法
public class TestRunnable implements Runnable{
int count = 0;
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
for(int i = 0; i < 5; i++){
count++;
System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
}
}
}
实现接口的好处
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
多线程的优点
提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
Thread类的方法
void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
线程的优先级
线程的优先级控制
MAX_PRIORITY（10）;
MIN _PRIORITY （1）;
NORM_PRIORITY （5）;
涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级
static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()：返回boolean，判断线程是否还活着
public class Test1 {
public static void main(String[] args) {
TestRun run0 = new TestRun();
TestRun run1 = new TestRun();
Thread t0 = new Thread(run0);
Thread t1 = new Thread(run1);
t0.setName("线程t-0");//设置线程的名称
t1.setName("线程t-1");//设置线程的名称
// t0.setPriority(1);//设置线程的优先级
// t1.setPriority(10);//设置线程的优先级
t0.start();
t1.start();
// System.out.println(t0.getName());//如果在创建线程的时候没有指定名称，系统会给出默认名称，通过getName()获取线程名称
// System.out.println(t1.getName());
/**
* 线程的优先级，就是哪个线程有较大个概率被执行
* 优先级是用数组1-10表示，数字越大优先级越高，如果没有设置默认优先级是5
*/
// System.out.println("t0的优先级：" + t0.getPriority());//获取线程的优先级
System.out.println("---------------1");
System.out.println("---------------2");
System.out.println(t1.isAlive());//判断当前的线程是否存活
t1.stop();//强制线程生命期结束,强制停止此线程
try {
t0.join();//相当于在这块把t0的run的代码插入到这个位置执行
/**
* 专业的说法
* 就是阻塞当前的main方法，先不执行System.out.println("---------------3");代码
* 先执行join进来的线程的代码
* join的线程执行完毕之后继续执行之前main方法阻塞的代码System.out.println("---------------3");
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("---------------3");
System.out.println(t1.isAlive());
}
}
class TestRun implements Runnable{
int count = 0;
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
for(int i = 0; i < 5; i++){
// try {
// Thread.sleep(1000);//当前线程睡眠1000毫秒
// //相当于当前的这个循环每隔1000毫秒执行一次循环
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// if(i % 2 == 0){
// Thread.yield();//线程让步
// }
count++;
System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
}
}
}
线程的生命周期
JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止
四、线程的同步
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
**Synchronized的使用方法
Java对于多线程的安全问题提供了专业的解决方式：
同步机制
1、synchronized还可以放在方法声明中，表示整个方法
为同步方法。
例如：
public synchronized void show (String name){
….
}
2、synchronized (对象）{
// 需要被同步的代码；
}
**
线程的死锁
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
专门的算法、原则，比如加锁顺序一致
尽量减少同步资源的定义，尽量避免锁未释放的场景
比如：a0需要调用f0 a1需要调用f1
但是a0调用f1的时候卡住，a1调用f0的时候卡住，这就是一个死锁问题
线程通信
wait() 与 notify() 和 notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常
wait()方法
在当前线程中调用方法： 对象名.wait()
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权 ，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
在当前线程中调用方法： 对象名.notify()
功能：唤醒等待该对象监控权的一个线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
关于线程同步和加锁的实例代码
public class Test2 {
public static void main(String[] args) {
//定义账户对象
Acount a = new Acount();
Acount a1 = new Acount();
//多线程对象
User u_weixin = new User(a, 2000);
User u_zhifubao = new User(a, 2000);
Thread weixin = new Thread(u_weixin,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
weixin.start();
zhifubao.start();
}
}
class Acount{
public static int money = 3000;//全局变量，所有的操作共享这个变量
/**
* 提款，判断账户钱够不够
* 多线程调用这个方法，就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
* 解决思路：显然一个线程整体执行完这个方法，另一个线程再执行
* 通过synchronized同步锁来完成
* 可以直接在方法上加上synchronized关键字
* 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
* 不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题
*
* 普通方法加同步锁，锁的当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁
* @param m
*/
public synchronized void drawing(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
}
public synchronized void drawing1(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
}
/**
* 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁
* @param m
*/
public static synchronized void drawing2(int m){
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
}
/**
* 对代码块加入同步锁
* 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
* @param m
*/
public void drawing3(int m){
synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
//用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
}
}
public void drawing4(int m){
synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
//用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
String name = Thread.currentThread().getName();
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
}
}
/**
* synchronized修饰代码块，想要根据不同的对象有不同的锁
* synchronized(a),这个小括号中传入不同的对象就是不同的锁
* @param m
*/
public void drawing5(int m,Acount a){
synchronized(a){//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
//不同的对象就有不同的同步锁
String name = Thread.currentThread().getName();
//如果是微信操作的，先不执行，等支付宝操作，支付宝操作完，微信再继续操作
if(name.equals("微信")){
try {
a.wait();//当前的线程进入等待的阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(money < m){
System.out.println(name + "操作，账户金额不足：" + money);
}else{
System.out.println(name + "操作，账户原有金额：" + money);
System.out.println(name + "操作，取款金额：" + m);
System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
money = money - m;
System.out.println(name + "操作，取款后的余额：" + money);
}
if(name.equals("支付宝")){
try {
a.notify();//唤醒当前优先级最高的线程，进入就绪状态
// a.notifyAll();//唤醒当前所有的线程，进入就绪状态
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
class User implements Runnable{
Acount acount;
int money;
public User(Acount acount,int money){
this.acount = acount;
this.money = money;
}
@Override
public void run() {
// acount.drawing(money);
// if(Thread.currentThread().getName().equals("微信")){
//// acount.drawing(money);
// acount.drawing3(money);
// }else{
//// acount.drawing1(money);
// acount.drawing4(money);
// }
// acount.drawing2(money);//调用类的静态方法
// acount.drawing3(money);
acount.drawing5(money, acount);
}
}
扫一扫
8794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
