当前位置 : 主页 > 编程语言 > java >

Java进阶——线程基础

来源：互联网 收集：自由互联 发布时间：2023-02-04
线程基础 1、线程介绍 1.1、线程相关概念 程序（program）：是完成特定任务，用某种语言编写的一组的集合（例如：java代码就是一个程序） 进程：是指运行中的程序（比如：我现在使用

线程基础

1、线程介绍

1.1、线程相关概念

  • 程序（program）：是完成特定任务，用某种语言编写的一组的集合（例如：java代码就是一个程序）
  • 进程：是指运行中的程序（比如：我现在使用的Typora）
    • 进程是程序的一次执行过程
    • 是动态的过程：由他自身的产生、存在和消亡的过程
  • 什么是线程？
    • 线程是由进程创建的，是进程的一个实体
    • 一个进程可以拥有多个线程
  • 其他概念
    • 单线程：同一时刻，只允许执行一个线程
    • 多线程：同一时刻，可以执行多个线程
    • 并发：同一时刻，多个任务交替执行（单CPU实现多任务就是并发）
    • 并行：同一时刻，多个任务同时执行（多核CPU可以实现并行）

2、线程基本使用

创建线程的两种方式：

2.1、 继承Thread 类，重写run方法

线程应用案例1——继承Thread类：

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 实体类 * <p> * 1.当一个类继承 Thread类， 该类就可以当做线程使用 * 2.我们会重写run方法，写上自己的业务代码 * 3.run Thread 类实现了 Runnable 接口的run方法 * public void run() { * if (target != null) { * target.run(); * } * } * </p> */ public class Cat extends Thread{ int times = 0; @Override public void run() { while(true) { // 每隔1秒，在控制台输出“喵喵,我是小猫咪" System.out.println("喵喵，我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 当times输出8次是我们就退出线程 if (times == 80) { break; } } } } /** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 线程的基本使用 */ public class Thread01{ public static void main(String[] args) throws InterruptedException { // 创建一个Cat对象,当线程使用 Cat cat = new Cat(); // 启动线程 cat.start(); // 当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行 // 主线程和子线程是交替执行的 System.out.println("主线程继续执行" + Thread.currentThread().getName()); for (int i = 0; i < 60; i++) { System.out.println("主线程 i = " + i); // 让主线成休眠 Thread.sleep(1000); } } }

启动线程为什么是start：

启动线程最终会执行cat的run方法，而cat.run()方法就是一个普通的方法，并没有真正的启动多线程，run执行完毕后才会向下执行

image-20221203101824177

我们可以追踪下源码进行分析

image-20221203102458667

image-20221203102447530

2.2、实现Runnable接口，重写run方法

线程应用案例2——实现Runnable接口：

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 通过实现Runnable接口， 开发线程类 */ public class Dog implements Runnable{ int count = 0; @Override public void run() { while (true) { System.out.println("Hello World!" + (++count) + Thread.currentThread().getName()); // 休眠1秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 10) { break; } } } } public class Thread02 { public static void main(String[] args) { Dog dog = new Dog(); // 这里不能调用start dog.start(); Thread thread = new Thread(dog); thread.start(); } }

在Thread thread = new Thread(dog);中使用到了一种设计模式：静态代理模式

在Thread类里面有个私有属性：==private Runnable target;==当我们实现Runnable接口的run方法时会调用如下的方法，

当我们==Thread thread = new Thread(dog)==;时，因为Dog实现了Runnable接口，所以这里的==dog==就相当于时==target==

个人理解：如有不对的地方请批评指正

@Override public void run() { if (target != null) { target.run(); } }

2.3、多线程的简单演示：

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 在main线程启动两个子线程 */ public class Thread03 { public static void main(String[] args) { T1 t1 = new T1(); T2 t2 = new T2(); Thread thread1 = new Thread(t1); Thread thread2 = new Thread(t2); thread1.start(); thread2.start(); } } class T1 implements Runnable{ int count = 0; @Override public void run() { while (true){ // 给隔1秒输出”hello world!" 输出10次 System.out.println("Hello World!" + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 10) { break; } } } } class T2 implements Runnable { int count = 0; @Override public void run() { while (true){ // 给隔1秒输出”hello world!" 输出10次 System.out.println("Hello" + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } if (count == 5) { break; } } } }

子线程的理解：

image-20221203130658810

2.4、继承Thread 和实现Runnable 的区别

  • 从java设计角度看，通过继承Thread和实现Runnable接口来创建线程本质上没有区别
  • 实现Runnable接口方式更加适合多个线程共享一个资源的情况，避免了单继承的限制
  • 建议使用Runnable接口的方式开启线程。

2.5、线程终止

  • 当线程完成任务后，会自动退出
  • 还可以通过使用变量来控制run方法退出的方式进行停止线程，即通知方式

线程终止演示：

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 线程的退出 */ public class ThreadEit_ { public static void main(String[] args) throws InterruptedException { Th th = new Th(); th.start(); // main线程去控制th线程的终止， 必修可以修改 loop // 让th退出run方法，从而终止 th线程 -> 通知方式 System.out.println("主线程休眠10S"); Thread.sleep(1000 * 10); th.setLoop(false); } } class Th extends Thread{ int count = 0; private boolean loop = true; @Override public void run() { while (loop) { try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Th 运行中...." + (++count)); } } public void setLoop(boolean loop) { this.loop = loop; } }

3、线程方法

3.1、线程常用的方法一：

方法名 说明 setName 设置线程名称，使之与参数name相同 getName 返回该线程的名字 start 使该线程开始执行；Java虚拟机底层调用该线程的start0方法 run 调用线程对象run方法 setPriority 更改线程的优先级 getPriority 获取线程的优先级 sleep 在指定的毫秒数内让当前正在执行的线程休眠 interrupt 中断进程

  • 注意事项和细节：

    • start底层会创建新的线程，调用run，run是一个简单方法调用，不会启动新线程
    • 线程优先级的范围

    image-20221203185642103

    • interrupt，中断线程，单并没有真正的结束线程，一般用于中断正在休眠线程
    • sleep：线程的静态方法，使当前线程休眠

演示：

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 线程方法的使用 */ public class ThreadMethod01 { public static void main(String[] args) throws InterruptedException { // 测试方法 Th th = new Th(); th.setName("小豪"); th.setPriority(Thread.MIN_PRIORITY); // 启动子线程 th.start(); // 主线程打印5 hi，然后进行中断，子线程休眠 for (int i = 0; i <= 5; i++) { Thread.sleep(1000); System.out.println("hi " + i); } System.out.println(th.getName() + " 线程优先级 = " + th.getPriority()); // 当执行到这里时，就会中断 th线程的休眠 th.interrupt(); } } class Th extends Thread { @Override public void run() { while (true){ for (int i = 0; i <= 100; i++) { // Thread.currentThread().getName() 获取当前线程名称 System.out.println(Thread.currentThread().getName() + "吃包子~~~~~~~~"); } try { System.out.println(Thread.currentThread().getName() + "休眠中~~~~~~"); Thread.sleep(20000); } catch (InterruptedException e) { // 当该线程执行到一个interrupt 方法时，就会catch 一个异常，可以加入自己的业务代码 System.out.println(Thread.currentThread().getName() + "被interrupt中断了~~~~~~"); } } } }

3.2、线程的常用方法二：

方法名称 解释说明 yield 线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功 join 线程的插队。插队线程一旦插入成功，则肯定先执行完插入的线程的所有任务

线程join说明：

image-20221203193312602

示例演示：

main线程创建一个子线程，每隔1s输出hello，输出20次，主线线程每隔1s输出 hi，输出20次，要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

/** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 线程方法的使用 */ public class ThreadMethod02 { public static void main(String[] args) throws InterruptedException { T2 t2 = new T2(); t2.start(); for (int i = 1; i<= 20; i++) { Thread.sleep(1000); System.out.println("主线程吃了" + i + " 包子"); if (i == 5) { System.out.println("主线程让子线程先吃"); // join，线程插队 // t2.join(); 这里是让t2线程执行完毕 Thread.yield(); System.out.println("子线程吃完主线程接着吃"); } } } } class T2 extends Thread { @Override public void run() { for (int i = 1; i <= 20; i++) { try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("子线程吃了" + i + "包子"); } } }

3.3、用户线程和守护线程

  • 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
  • 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  • 常见的守护线程：垃圾回收机制

    • 演示示例：

    /** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 守护线程演示 */ public class ThreadMethod0 { public static void main(String[] args) throws InterruptedException { MyDaemonThread myDaemonThread = new MyDaemonThread(); myDaemonThread.start(); // 当主线程结束后，子线程自动结束，只需将子线程设置为守护线程即可 myDaemonThread.setDaemon(true); for (int i = 1; i <= 10; i++) { System.out.println("小豪再敲代码"); Thread.sleep(10000); } } } class MyDaemonThread extends Thread { @Override public void run() { for (; ;) { try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("小豪在和女友聊天......"); } } }

    4、线程生命周期

    线程状态。 线程可以处于以下状态之一：

    • NEW : 尚未启动的线程处于此状态。
    • RUNNABLE 在Java虚拟机中执行的线程处于此状态。
    • BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
    • WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
    • TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
    • TERMINATED 已退出的线程处于此状态。

    image-20221203203948478

    实例演示：

    /** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 线程的状态 */ public class Threadstate_ { public static void main(String[] args) throws InterruptedException { T t = new T(); System.out.println(t.getName() + "状态 " + t.getState()); t.start(); while (Thread.State.TERMINATED != t.getState()) { System.out.println(t.getName() + "状态 " + t.getState()); Thread.sleep(500); } System.out.println(t.getName() + "状态 " + t.getState()); } } class T extends Thread { @Override public void run() { while (true){ for (int i = 0; i < 10; i++) { System.out.println("hi " + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } break; } } }

    运行结果：

    image-20221203204933521

    5、Synchronized

    **线程同步机制：**在多线程编程，一些敏感数据不允许被多线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

    • 同步具体方法—Synchronized

      • 同步代码块
      synchronized(对象) { // 得到对象的锁，才能操作同步代码 // 需要被同步的代码; }
      • synchronized还可以放在方法声明中，表示整个方法—为同步方法
      public synchronized void m(String name) { // 需要被同步的代码; }

    使用synchronized解决火车票超卖问题

    /** * @author java小豪 * @version 1.0.0 * @date 2022/12/3 * @description 模拟售票 */ public class SellTicket { public static void main(String[] args) { // 解决火车票超卖问题 SellTicket03 sellTicket03 = new SellTicket03(); Thread thread1 = new Thread(sellTicket03); Thread thread2 = new Thread(sellTicket03); Thread thread3 = new Thread(sellTicket03); thread1.start(); thread2.start(); thread3.start(); } } /** 实现接口方式, 使用synchronized实现线程同步**/ class SellTicket03 implements Runnable{ private int ticketNum = 100; private boolean loop = true; public synchronized void m() { // 同步方法，在同一时刻，只能有一个线程来执行run方法 if (ticketNum <= 0) { System.out.println("售票结束..."); loop = false; return; } // 休眠50秒 try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票" + " 剩余票数 = " + (--ticketNum)); } @Override public void run() { while (loop) { // m方法是一个同步方法 m(); } } }

    6、互斥锁

    基本介绍：

    • Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
    • 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，该对象只能被一个线程调用
    • 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问
    • 同步的局限性：导致程序的执行效率要降低
    • 同步方法（非静态的）的锁可以使this，也可以是其他对象
    • 同步方法（静态的）的锁为当前类本身

    image-20221204221602909

    • 同步方法（静态的）的锁为当前类本身

    image-20221204222202804

    注意事项和细节：

  • 同步方法如果没有使用static修饰：默认锁对象为this
  • 如果方法使用static修饰，默认锁对象：当前类
  • 实现的落地步骤：
  • 需要先分析上锁的代码
  • 选择同步代码块和同步方法
  • 要求多个线程的锁对象为同一个即可

    • 7、死锁

    基本介绍：

    多个线程都占用了对方的锁资源，始终不肯释放，就导致了死锁

    案例演示：

    /** * @author java小豪 * @version 1.0.0 * @date 2022/12/4 * @description 死锁模拟 */ public class DeadLock_ { public static void main(String[] args) { // 模拟死锁现象 DeadLockDemo A = new DeadLockDemo(true); A.setName("A线程"); DeadLockDemo B = new DeadLockDemo(false); B.setName("B线程"); A.start(); B.start(); } } class DeadLockDemo extends Thread { static Object o1 = new Object(); static Object o2 = new Object(); boolean flag; public DeadLockDemo(boolean flag) { this.flag = flag; } @Override public void run() { // 1.如果flag为 T，线程A 就会先得到 o1对象锁， 然后尝试去获取 o2 对象锁 // 2.如果线程A 得不到 o2 对象锁，就会Blocked // 3.如果flag为 F, 线程B 就会先得到 o2对象锁，然后尝试去获取 o1 对象锁 // 4.如果线程B 得不到 o1 对象锁， 就会Blocked if (flag) { synchronized (o1) { System.out.println(Thread.currentThread().getName() + " 进入1"); synchronized (o2) { System.out.println(Thread.currentThread().getName() + " 进入2"); } } } else { synchronized (o2) { System.out.println(Thread.currentThread().getName() + " 进入3"); synchronized (o1) { System.out.println(Thread.currentThread().getName() + " 进入4"); } } } } }

    释放锁

    • 下面操作会释放锁
      • 当前线程的同步方法、同步代码块执行结束
      • 当前线程在同步代码块、同步方法中遇到break、return
      • 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception，导致异常结束
      • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
    • 下面操作不会释放锁
      • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
      • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁应避免suspend()和resume()方法来控制线程
    上一篇：Java进阶——IO流
    下一篇：没有了
    网友评论
    相关栏目
    最近更新
    热门文章