JavaSE：多线程

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量87 收藏
点赞数
分类专栏： JavaSE 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49825096/article/details/108457874
版权

JavaSE：多线程

程序、进程和线程

**程序：**为了完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
**进程：**程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有它自身的产生、存在和消亡的过程。
**线程：**进程课进一步细化为线程，是一个程序内部的一条执行路径。

说明：

  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间，他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

一个Java应用程序java.exe ，其实至少有三个线程：main（）主线程，gc垃圾回收线程，异常处理线程。

并行于并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的的事

并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事

使用多线程的优点

1.提高应用程序的响应。对图形化界面更有意义，可增强用户一滩。

2.提高计算机系统CPU的利用率。

3.改善程序结构。将既长又复杂的进程分为多个进程，独立运行，利于理解和修改。

线程的创建和使用

方式一：继承thread类

步骤：

  • 创建一个继承于thread 类的子类
  • 重写Thread 类的run()方法
  • 将此线程执行的操作声明在run()方法中
  • 创建Thread 类的子类和对象
  • 通过对象调用start()方法，使线程进入就绪状态

注意：

  • 不能够使用直接调用run() 方法启动线程。
  • 不可以再次调用已经start 的线程。

示例

//1.创建一个继承于Thread的子类
class MyThread extends Thread{
    //2.重写thread类中的run()
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println("线程MyThread:" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建子类对象
        MyThread t1 = new MyThread();
        //4.通过对象调用start（）
        t1.start();
        for(int i = 0;i < 100;i++){
            if(i % 2 != 0){
                System.out.println("主线程main：" + i);
            }
        }
    }
}

运行结果：
两个线程随机交替执行

线程中常用的方法

  1. start（）启动当前线程：调用当前线程的run（）
  2. run（）：通常需要重写Thread 类中的此方法，将创建的线程要执行的操作声明在此方法中
  3. currentThread（）：静态方法，返回执行当前代码的线程
  4. getName（）：获取当前线程的名字
  5. setName（）：设置当前线程的名字
  6. yield（）：释放当前cpu 的执行权
  7. jion（）：在线程a中调用线程b的jion（），此时线程a就进入阻塞状态，直到线程b完成执行后，线程b才结束阻塞状态
  8. stop（）：已过时。当执行此方法时，强制结束当前线程
  9. sleep（long millitime）：让当前线程“睡眠”指定的millitime 毫秒。在指定的millitime 毫秒时间内，当前线程是阻塞状态。
  10. isAlive（）：判断当前线程是否存活

线程的优先级

线程的优先级：

MAX_PRIORITY：10

MIN_PRIORITY：1

NORM_PRIORITY：5 -------->默认优先级

如何获取和设置当前线程的优先级：

getPriority（）：获取当前线程优先级

setPriority（）：设置当前线程优先级

在分线程开始之前设置优先级

注意：

  • 高优先级并不意味着一定优先执行，只是提高了优先执行的概率。
  • 线程创建时继承父线程的的优先级。

方式二：实现Runnable接口

创建步骤：

  1. 定义子类，实现Runnable接口
  2. 子类中重写Runnable接口中的run 方法
  3. 通过Thread类含参构造器创建线程对象。
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
  5. 调用Thread类的start 方法：开启线程，调用Runnable子类接口的run方法。

示例

//1.创建一个实现Runnable接口的类
class MyThread implements Runnable{
    @Override
    //2.实现类去实现Runnable中的抽象接口run（）
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){

                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadText02 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread thread = new MyThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(thread);
        t1.setName("线程1001");
        //5.通过Thread类的对象调用start（）
        t1.start();

        //多线程
        Thread t2 = new Thread(thread);
        t2.setName("线程1002");
        t2.start();
    }

}

运行结果：
在这里插入图片描述
使用实现Runnable接口的好处：

  • 避免了类单继承的局限性
  • 多个线程可以共享一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

线程的声明周期

一个线程完整的生命周期通常要经历如下五个阶段：

  1. 新建：当一个Thread类或其子类的对象被声明并创建，新生的线程对象就处于新建状态
  2. 就绪：新建状态的线程在被调用strat 方法后，将进入线程队列等到CPU时间片，此时处于就绪状态
  3. 运行：当就绪状态的线程被调度，获取了CPU资源之后，就会进入运行状态，执行run方法中的代码
  4. 阻塞：在某种特殊的情况下，被认位挂起或执行输入输出操作时，让出CPU资源暂停执行本线程，进入阻塞状态
  5. 死亡：当线程完成了它的全部工作，或者线程被提前强制性结束，或者出现异常时，线程死亡

在这里插入图片描述

线程的同步

问题的出现：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

Synchronized 的使用

同步锁机制：

在多线程中，为了防止多个线程对同一共享资源同时访问的情况发生，就需要对共享资源加上一个锁，使得一个线程在访问此共享资源时，其他要访问此共享资源的线程必须等待，直到正在访问的线程释放锁，其他线程之一才能访问此共享资源。

Sychronized的锁：

  1. 任意对象都可以作为同步锁，所有对象都自动含有单一的锁。
  2. 同步方法的锁：静态方法（类名.class）、非静态方法（this）
  3. 同步代码块：可以自己任意指定，通常也指定为this或 类名.class

注意：

  • 必须保证同一个资源的多个线程共用同一把锁，否则无法保证线程安全。
  • 一个线程类中的所有静态方法共用同一把锁（类名.class） ，所有非静态方法公用同一把锁（this）

方式一：同步代码块

方式一:同步代码块
  synchronized(同步监视器){
      //需要被同步的代码

  }
示例

未加锁，导致相同票号重复卖出，共享数据未同步。

class Windows extends Thread{
    private static int ticket = 10;

    @Override
    public void run() {

        while (ticket > 0){
            System.out.println(getName() + ":卖票，票号为：" + ticket );
            ticket--;
        }
        if (ticket == 0){
            System.out.println("售票完毕");
        }
    }
}

public class WindowsExer {
    public static void main(String[] args) {

        Windows w1 = new Windows();
        Windows w2 = new Windows();

        w1.setName("窗口一");
        w2.setName("窗口二");

        w1.start();
        w2.start();
    }
}

运行结果：
在这里插入图片描述

添加锁，解决问题

class Windows02 implements Runnable{
    private int ticket = 10;

    @Override
    public void run() {
        while (true) {
            synchronized (Windowss02.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    System.out.println("票已售罄");
                    break;
                }
            }
        }
    }
}

public class WindowsExer02 {
    public static void main(String[] args) {
        Windows02 w = new Windows02();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");

        t1.start();
        t2.start();
    }
}

运行结果：不在出现重复售票问题。
在这里插入图片描述

方式二：同步方法

用同步方法实现同上售票案例

class Windows03 implements Runnable{
    private int ticket = 20;

    @Override
    public void run() {
        while (ticket > 0) {
            sale();
        }
    }

    private synchronized void sale(){//同步监视器：this
    //同步方法
     	System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
        ticket--;
    }
}

public class WindowSExer03 {
    public static void main(String[] args) {
        Windows03 w = new Windows03();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");

        t1.start();
        t2.start();
    }
}

运行结果：同样解决了重复售票的问题。
在这里插入图片描述

Lock 锁（JDK 5.0新增）

解决同一问题的方式三：lock锁

class Window implements Runnable{
    private int sticket = 21;
    //实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //调用一个锁定的方法lock（）
                lock.lock();
                if (sticket > 0){
                    System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + sticket );
                    sticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁的方法unlock（）
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);

        t1.setName("线程一");
        t2.setName("线程二");

        t1.start();
        t2.start();
    }
}

运行结果：
在这里插入图片描述
注意：lock锁是显示锁，需要自己手动开启，手动关闭。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。

线程的通信

线程间通信的三个常用方法
wait（）：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

notify（）；一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级最高的线程

notifyAll（）：一旦执行此方法，就会唤醒所有被wait的线程

注意：

  1. wait（），notify，notifyAll（）三个方法必须使用在同步代码块活同步方法中
  2. 这三个方法的调用者必须是同步代码块活同步方法的同步监视器，否则会出现IllegalMonitorStateException异常
  3. 这三个方法是定义在java.lang.Object类中的。

示例：交替打印1-50

public class CommunicationTest {
    public static void main(String[] args) {
        Number num = new Number();

        Thread t1 = new Thread(num);
        Thread t2 = new Thread(num);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}


class Number implements Runnable{
    int number = 1;

    @Override
    public void run() {
        while (number < 50){
            synchronized (this){
                this.notify();
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + ":" + number);
                number++;
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：
在这里插入图片描述

JDK 5.0 新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比，Callable功能更强大些

  1. 相比run（）方法，可以有返回值
  2. 方法可以抛出异常
  3. 支持泛型的返回值
  4. 需要借助FutureTask类，比如获取返回结果

步骤：

  1. 创建一个实现Callable 的实现类
  2. 实现call方法，将此线程需要执行的操作声明在call（）中
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递
  6. 到Thread类的构造器中，创建Thread对象，并调用start（）；
  7. 获取Callable中call方法的返回值，get()方法返回值即为FutureTask构造器参数Callable实现类重写的call（）的返回值

示例：

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //实现call（）方法，将此线程需要执行的操作声明再call（）中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread num = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(num);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start（）；
        Thread thread = new Thread(futureTask);
        thread.start();
        //6.获取Callable中call()方法的返回值
        //get()方法返回值即为FutureTask构造器参数Callable实现类重写的call（）的返回值
        try {
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

方式二：线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

好处：

  1. 提高相应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  3. 便于线程管理

示例：

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


class CallThread implements Callable{

    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
        return null;
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2. 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合用于Runnable
        service.submit(new CallThread());//适合用于Callable
        
        //关闭线程池
        service.shutdown();

    }
}

运行结果：
在这里插入图片描述

merlin梅林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE经典面试题：多线程
LSFZ88888的博客
03-27 657
01：线程和进程的区别? 　　进程： 　　具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位。 　　线程： 　　是进程的一个实体，是 cpu 调度和分派的基本单位，是比进程更小的可以独立运行的基本单位。 　　特点： 　　线程的划分尺度小于进程，这使多线程程序拥有高并发性， 　　进程在运行时各自内存单元相互独立，线程之间内存共享， 　　这使多线程编程可以拥有更好的性能和用户体验 　　注意：多线程编程对于其它程序是不友好的，占据大量 cpu 资源
11、JavaSE：多线程.pdf
04-24
看B站视频项目总结的系列文档，仅供个人学习使用
Java 笔记 17：JavaSE：多线程基础，单例设计模式（重要）
qq_40473204的博客
07-25 979
Java 笔记 17JavaSE：多线程基础线程的生命周期线程安全问题死锁生产者，消费者问题单例设计模式（重要） JavaSE：多线程基础 多线程相关知识的课程安排： 1、JavaSE：多线程基础 2、后面：多线程高级 juc 多线程相关的一些概念：（了解） 程序： 当你要完成某个/些任务，功能时，选择一种编程语言而编写的一组指令的集合。 软件： 软件 = 程序 + 程序运行所需要的一些资源文件。 一个软件中可能会有很多个程序构成。 进程： 程序的一次运行。 每个进程之间是独立。操作系统在分配资源（例
JavaSE：第十四章：多线程
weixin_44519496的博客
09-13 68
史上最全的知识体系脑图，覆盖所有知识点，所有细节，注意事项。 多线程：包含程序、进程、线程的概念，Java中多线程的创建和使用，实现 Runnable 接口与继承 Thread 类，Thread类的主要方法，线程的调度与设置优先级，线程的生命周期，线程的同步，线程的通信。 更多请见：http://www.mark-to-win.com/tutorial/51134.html ...
JAVASE之多线程初识
YoungLee16的博客
12-10 405
多线程: 进程:进程指正在运行的程序,确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能. 线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程.一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序.   简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程. 多线程:即就是一个程
JavaSE——多线程详细
weixin_51351637的博客
12-12 647
一个应用程序，一个进程就是一个软件：一个进程中的执行场景/执行单元对于java程序来说，当在DOS命令窗口中输入java HelloWorld回车之后，会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾，也就是说java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
JavaSE基础：多线程
weixin_44675404的博客
03-01 80
JavaSE基础：多线程 文章目录JavaSE基础：多线程前言一、基本概念1、什么是进程？什么是线程？2、java程序中的线程3、进程和线程的关系4、对于单核的CPU来说，真的可以做到真正的多线程并发吗？5、实现线程的两种方式6、线程对象的生命周期二、线程的调度和数据安全1、常用的线程调度模型2、有关线程调度的方法3、数据安全（重点）4、存在安全问题的三个条件5、解决线程安全问题6、异步和同步编程模型7、三大变量的线程安全问题8、局部变量的使用9、synchronized三种写法三、守护线程1、概念2、例子
JavaSE基础篇：多线程
热门推荐
七叔的博客
08-26 1万+
JavaSE基础篇：多线程
Javase | 多线程
m0_70720417的博客
12-01 1570
多线程： 1.程序 2.进程 3.线程 4.多线程 5.自定义线程类 : 5.1 继承Thread类 5.2 实现Runnable接口 6.多线程的生命周期及状态转换 新建状态 (New) 就绪状态 (Runnable) 运行状态 (Running) 阻塞状态 (Blocked) 死亡状态 (Terminated) 7.多线程的调度 线程的优先级 线程的休眠 线程的让步 yield() 和 sleep() 的区别 8.多线程同步和通信 8.1 多线程的同步 8.2 多线程通信 .....
javaSE之多线程vip插队
小小雨伞的博客
10-07 566
//测试join方法 //想象为插队 public class TestJoin implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("线程vip来了"+i); } } public static void main(String[] args) throw
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
（javaweb）请求响应postman
2301_79144798的博客
08-08 483
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 271
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 236
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 453
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
JavaSE编程：多线程泡茶实例解析
在这个JavaSE编程案例中，我们看到了如何使用多线程来模拟泡茶的过程。首先，我们有两个线程类：`BoilThread`（烧开水的线程）和`WashThread`（洗茶杯的线程）。这两个线程分别代表泡茶过程中的两个不同任务，烧开水...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值