Java多线程

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量114 收藏
点赞数
分类专栏： Java学习 文章标签： java 开发语言 eclipse 学习 经验分享 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64681789/article/details/129405437
版权

前言

程序：为完成特定任务，用某种语言编写的一种指令的集合。即指一段静态的代码，静态对象。
进程：程序的一次执行过程，或是正是运行的一个程序。是一个动态的过程，是 操作系统结构的基础。
线程：是操作系统能够进行运算调度的最小单位。进程可以进一步细化成线程，是一个程序内部的一条执行路线。
相关说明：
（1）若一个进程统一时间并行执行多个线程，就是支持多线程
（2）线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小
（3）一个进程中的多个线程共享相同的内存单元/地址空间。但是多线程操作共享的系统资源可能会带来安全隐患。

一、多线程的优点

1.提高应用程序的响应。对图形化界面更有意义，可以增强用户的体验。
2.提高计算机系统CPU的利用率。
3.改善程序结构，将复杂的进程分为多个线程，独立运行，利于理解和修改。、

二、线程的创建和启动

2.1 Thread类

2.1.1 Thread类的使用

（1）创建一个继承于Thread类的子类。
（2）重写Thread类的run()方法。
（3）创建Thread类的子对象。
（4）通过此对象调用start()。

2.1.2 Thread类的实现例子

package cn.exe.p1;

public class ThreadTest {

    public static void main(String[] args) {
        
        AA a1 = new AA();   
        a1.start();   //通过start()方法启动线程
        
        AA a2 = new AA();
        a2.start();
    }
}

class AA extends Thread{
    
    //重写Thread类的run()方法
    @Override
    public void run() {
        for(int i = 0;i < 10;i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    
}

输出结果：

2.1.3 Thread类的相关的方法介绍

  1. start()：启动当前线程，执行当前线程的run()方法。

  1. run()：通常需要重写Thread类中的此方法，将创建的线程需要执行的操作声明在此方法中。

  1. currentThread()：静态方法，返回当前代码执行的线程。

  1. getName()：获取当前线程的名字。

  1. setName()：设置当前线程的名字。

  1. yield()：释放当前CPU的执行权。

  1. join()：在线程x中调用线程y的join()，此时线程x进入阻塞状态，直到线程y完全执行完以后，线程x才结束阻塞状态。

  1. stop()：已过时。执行此方法时，强制结束当前线程。

  1. sleep()：让当前线程“睡眠”指定的时间（毫秒），在睡眠时间内，当前线程是阻塞状态。

  1. isAlive()：返回boolean类型，判断线程是否还活着。

2.2 Runnable接口

2.2.1 Runnable接口的使用

（1）创建一个实现了Runnable接口的类。
（2）实现类去实现Runnable中的抽象方法run()。
（3）创建实现类的对象。
（4）将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
（5）通过Thread类的对象调用start()。

2.2.2 Runnable接口的实现例子

package cn.exe.p1;

public class RunnableTest {
    public static void main(String[] args) {
        BB b1 = new BB();  //创建BB的实例对象
        
        //将BB的实例对象作为参数传递到Thread类的构造器中，创建Thread类的实例对象
        Thread thread = new Thread(b1);
        
        thread.start();  //通过start()方法启动线程
        
        BB b2  = new BB();
        Thread thread2 = new Thread(b2);
        
        thread2.start();
    }
}

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

输出结果：

2.3 Callable接口

2.3.1 Callable接口的使用

（1）创建一个实现Callable的实现类。
（2）实现call()方法，将此线程需要执行的操作声明在call()中。
（3）创建Callable接口实现类的对象。
（4）将此Callable接口实现类的对象传递到FutureTask构造器中，创建FUtureTask的对象。
（5）将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()。

2.3.2 Callable接口的实现例子

package cn.exe.p1;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) {
        CC c1 = new CC();
        
        FutureTask task = new FutureTask(c1);
        
        new Thread(task).start();
        try {
            Object sum = task.get();
            System.out.println("sum = " + sum);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

class CC implements Callable{
    public Object call() throws Exception{
        
        //将需要执行的操作放置在call()方法中
        int sum = 0;
        for(int i = 1;i <= 10;i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            sum += i;
        }
        return sum;
    }
}

输出结果：

2.3.3 Callable接口的好处

call()可以有返回值。
call()可以抛出异常，被外面的操作捕获，获取异常的信息。
Callable是支持泛型的。
需要借助 FutureTask类。

2.3.4 Future接口

1. 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
2. FutureTask是Future接口的唯一的实现类。
3. FutureTask同时实现了Runnable。Future接口，既可以作为Runnable被线程执行，又可以作为4. Future得到Callable的返回值。

2.4 线程池

2.4.1 线程池的使用

（1）提供指定线程数量的线程池。
（2）设置线程池的属性。
（3）执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象。
（4）关闭连接池。

2.4.2 线程池的实现方式

package cn.exe.p1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPoolTest {
    public static void main(String[] args) {
        
        //指定线程数量
        ExecutorService service = Executors.newFixedThreadPool(8);
        
        ThreadPoolExecutor executor = (ThreadPoolExecutor)service;
        
        service.execute(new DD());  //适用于Runnable
        
        service.execute(new EE());
        
//        Callable使用 service.submit(Callable callable);
    
        service.shutdown();  //关闭线程池
    }
}

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

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

输出结果：

2.4.3 线程池的相关方法

corePoolSize()：设置核心池的大小
maximumPoolSize()：设置最大线程数
keepALiveTime()：线程没有任务时最多保持多久的时间会终止

2.4.5 线程池的好处

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

2.4.6 线程池的相关API

（1） void execute(Runnable command) ：执行任务 / 命令，没有返回值，
一般用来执行Runnable。
（2） Future submit(Callable task)：执行任务，有返回值，一般又来执行
Callable。
（3） void shutdown()：关闭连接池。
（4） Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线
程池。
（5） Executors.newCachedThreadPool()：创建一个可根据需要创建新线程
的线程池。
（6） Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程
池。
（7） Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程
池。
（8） Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在
给定延迟后运行命令或者定期地执行。

三、线程的生命周期

线程一共有以下5种状态： 新建、就绪、运行、阻塞、死亡
新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，这时它就具备了运行的条件。
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态。
阻塞：在某种特殊请款下，被人为的挂起或执行输入输出操作时，让出CPU并终止自己的执行，从而进入阻塞状态。
死亡：线程完成了它的全部工作或被线程提前强制中止或出现异常而终止。

四、线程的同步

此处涉及同步代码块和同步方法（解决线程安全的问题）

4.1 同步代码块的实现

Synchronized（同步监视器）{
//被同步的代码（操作共享数据的代码）
}

  1. 共享数据：多个线程共同操作的变量

  1. 同步监视器：也可以称之为锁。任何一个类的对象都可以来充当锁。

  1. 但是多个线程必须要共用同一把锁。

4.2 同步方法的实现

1. 同步方法：如果操作共享数据的代码完整的声明在一个方法种，可以将此方法声明位同步的。
2. 局限性：操作同步代码时，只能有一个线程参与，其他线程等待，效率低。
3. 同步方法仍涉及同步监视器，只是不需要显式的声明
4. 同步监视器：非静态的同步方法：this
静态的同步方法：当前类本身

4.3 Lock锁解决线程安全

Lock锁

ReentrantLock 类实现了 Lock ，它拥有与 synchronized
相同的并发性和内存语义，在实现线程安全的控制中，
比较常用的是ReentrantLock，可以显式加锁、释放锁。

Lock锁的相关方法

lock()：获取锁,如果锁不可用，则当前线程将被禁用以用于线程调度目的并处于休眠状态，直到获得锁为止。
lockInterruptibly()：除非当前线程被中断，否则获取锁。
tryLock()：这种用法确保锁在获得时解锁，并且在未获得锁时不尝试解锁。返回布尔类型(true/false)。
tryLock()：在给定的等待时间内空闲并且当前线程没有被中断，则获取锁,如果锁可用，则此方法立即返回值true。
unlock()释放锁。

4.3.1 Lock锁实现方式

package cn.exe.p1;

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    public static void main(String[] args) {
        GG g1 = new GG();
        
        Thread t1 = new Thread(g1);
        Thread t2 = new Thread(g1);
        Thread t3 = new Thread(g1);
        
        t1.setName("first");
        t2.setName("second");
        t3.setName("fird");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

class GG implements Runnable{
    
    private int number = 30;
    
    private ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while(true) {
            try {
                
                lock.lock();  //锁定方法
                
                if(number > 0) {
                    try {
                        Thread.sleep(150);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number--;
                }else {
                    break;
                }
            }finally {
                lock.unlock();   //解锁方法
            }
        }
    }
}

输出结果：

注意：如果同步代码有异常，要将 unlock() 写入 finally 语句块。

4.4 synchronized与Lock的区别

相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。
Lock需要手动的启动/结束同步监视器。

五、线程的调度

调度策略：
（1）分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
（2）抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点（Java使用的就是抢占式调度模型）

六、线程的优先级

线程的优先级：MAX_PRIORITY：10
MIN_PRIORITY：1
NORM_PRIORIITY：5（默认优先等级）
相关的方法的使用：
getPriority()：返回线程的优先级。
setPriority(): 改变线程的优先级。
说明：高优先级的线程要占领低线程CPU的执行权，只是从概率上讲高优先级的线程会被高概率先执行。

七、死锁

7.1 死锁的理解

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃资源，以此形成了死锁。

7.2 死锁的说明

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

7.3 死锁的代码实例

package cn.exe.p1;

public class LockTest2 {
    public static void main(String[] args) {
        
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        
        new Thread() {
            @Override
            public void run() {
                synchronized(s1) {
                    s1.append("a");
                    s2.append("first");
                    
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    
                    synchronized(s2) {
                        s1.append("b");
                        s2.append("second");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(s2) {
                    s1.append("c");
                    s2.append("third");
                    
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    
                    synchronized(s1) {
                        s1.append("d");
                        s2.append("fourth");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

八、线程的通信

线程通信主要涉及到三个方法： wait()、notify()、notifyAll()。
wait()：执行此方法，当前线程就会进入阻塞状态，并释放同步监视器。
notify()：执行此方法，就会唤醒一个被wait的线程，如果有多个被wait的线程就会唤醒优先级最高的那个线程。
notifyAll()：执行此方法，就会唤醒所有被wait的线程。

8.1 相关说明

（1）wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
（2）wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步监视器。
（3）wait()，notify()，notifyAll()三个方法是定义在Java.lang.object类中。

8.2 sleep()和wait()的比较

相同点：一旦执行方法，都可以使得当前线程进入阻塞状态。
不同点： 1.两个方法的声明位置不同：
Thread类中声明sleep()
object类中声明wait()
2.调用的要求不同：
sleep()可以在任何需要的场景下调用。
wait()必须使用在同步代码块或同步方法中。
sleep()不会释放锁，wait()会释放锁

8.3 代码示例

package cn.exe.p1;

public class CommunicationTest {
    public static void main(String[] args) {
        HH h1 = new HH();
        
        Thread t1 = new Thread(h1);
        Thread t2 = new Thread(h1);
        Thread t3 = new Thread(h1);
        
        t1.setName("first");
        t2.setName("second");
        t3.setName("third");
        
        t1.start();
        t2.start();
        t3.start();
        
    }
}

class HH implements Runnable{
    
    private int number = 40;
    public Object object = new Object();
    
    @Override
    public void run() {
        while(true) {
            synchronized (object) {
                object.notify();
                    if(number >= 0) {
                        try {
                            Thread.sleep(20);
                        }catch(InterruptedException e){
                            e.printStackTrace();
                        }
                        
                        System.out.println(Thread.currentThread().getName() + ":" + number);
                        number--;
                        
                        try {
                            object.wait();  //调用wait()方法让线程进入阻塞状态
                        }catch(InterruptedException e){
                            e.printStackTrace();
                        }
                    }else {
                        break;
                    }
            }
        }
    }
}

输出结果：（选取了小部分）

最后到这里，文章就结束了，如果在内容上有问题，恳请各位大佬指出。

ice-Hamster
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4174
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程使用教程
鹏鹏2077
04-25 5294
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
JAVA多线程是什么
qq_45022104的博客
08-31 4053
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 18万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7778
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
JAVA多线程实战
超级氯化钾的博客
07-21 2362
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 625
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 706
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1136
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值