JAVA高级--多线程

原创 已于 2022-07-25 10:36:50 修改 · 132 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-07-21 11:28:43 首次发布
本文详细解析了线程的概念，进程与线程的区别，线程的组成、特点和创建方式，包括继承Thread、Runnable接口和Callable接口。此外，讲解了线程安全、死锁、通信、线程池及其应用，以及手动锁和Lock接口的使用。

1.什么是线程?

        线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

2.进程和线程的区别

1. 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。

2. 一个程序运行后至少有一个进程。

3. 一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义。

4. 进程间不能共享数据段地址，但是同进程的线程之间可以。

2.1线程的组成

任何一个线程都具有基本的组成部分CPU时间片: 操作系统（OS）会为每个线程分配执行时间。    运行数据:

堆空间: 存储线程需要的对象，多个线程可以共享堆中的数据。 栈空间:  存储线程需使用的局部变量，每个线程都拥有独立的栈。            

线程的逻辑代码.

2.2线程的特点

1. 线程抢占式执行，效率高，可防止单一线程长时间独占CPU。

2. 在单核CPU中，宏观上同时执行，微观上顺序执行。

3.创建线程的三种方式

1. 继承Thread类，重写run方法

 2. 实现Runnable接口 

3.  实现Callable接口

继承Thread类的代码：

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程======================"+i);
        }
    }
}

 测试：

public class Test01 {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        m1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程============="+i);
        }
    }
}

继承Runnable接口：四个窗口卖100张票

public class MyThread implements Runnable{
private Integer ticket = 100;
Lock l = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                if (ticket>0){
                        ticket--;
                        System.out.println(Thread.currentThread().getName()+"卖了一张还剩："+ticket+"张");
                }else {
                    break;
                }
            } 
        }
    }
}

 测试：

public class Test01 {
    public static void main(String[] args) {
       MyThread myThread = new MyThread();
       Thread t1 = new Thread(myThread,"窗口A");
       Thread t2 = new Thread(myThread,"窗口B");
       Thread t3 = new Thread(myThread,"窗口C");
       Thread t4 = new Thread(myThread,"窗口D");
       t1.start();
       t2.start();
       t3.start();
       t4.start();
    }
}

 获取线程的名字和设置线程的名字：

MyThread m1 = new MyThread();
m1.setName("一号窗口");
String name = m1.getName();
System.out.println(name);

4.线程中的方法

4.1休眠

 public static void sleep(long millis)      当前线程主动休眠millis毫秒。

public class TakeSleep {
    public static void main(String[] args) {
        T t = new T();
        t.start();
        for (int i=0;i<20;i++){
            System.out.println("main==========="+i);
        }
    }
}
class T extends Thread{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            try {
                Thread.sleep(100);//是当前的线程进入一段休眠状态
                System.out.println("这是第"+i+"次");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}

4.2放弃

public static void yield()       当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

代码：

public class T extends Thread{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            Thread.yield();//可能导致t1和t2的交替的频率变得高了。当前的线程主动放弃时间片，回到就绪状态，再和其他的竞争下一次的时间片
            System.out.println(Thread.currentThread().getName()+"第"+i+"次");
        }
    }
}

 测试：

public class TestYield {
    public static void main(String[] args) {
        T t1 = new T();
        t1.setName("张三");
        T t2 = new T();
        t2.setName("李四");
        t1.start();
        t2.start();
    }
}
public class TestYield {
    public static void main(String[] args) {
        T t1 = new T();
        t1.setName("张三");
        T t2 = new T();
        t2.setName("李四");
        t1.start();
        t2.start();
    }
}

4.3加入

public final void join()       允许其他线程加入到当前线程中

代码：

public class ThreadJoin extends Thread{
    @Override
    public void run() {
        for (int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"这是第"+i+"次");
        }
    }
}

 测试：

public class Test01 {
    public static void main(String[] args) throws Exception{
        ThreadJoin j = new ThreadJoin();
        j.setName("A");

        j.start();
        j.join();
        //把线程ThreadJoin加入当前的main线程中,直到ThreadJoin线程执行完毕后,main才会执行

        for (int i=0;i<20;i++){
            System.out.println("main==================="+i);
        }
    }
}

4.4守护线程

线程对象.setDaemon(true);设置为守护线程。 线程有两类:用户线程（前台线程）和守护线程（后台线程）如果程序中所有前台线程都执行完毕了，后台线程也会自动结束。

代码：

public class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for (int i=0;i<50;i++){
            System.out.println(Thread.currentThread().getName()+"第"+i+"次");
        }
    }
}

 测试：

public class Test01 {
    public static void main(String[] args) {
        ThreadDaemon t = new ThreadDaemon();
        t.setName("A");
        t.setDaemon(true);//设置ThreadDaemon为守护线程，当前台线程都执行完毕后，守护线程也会自动结束
        t.start();
        for (int i=0;i<20;i++){
            System.out.println("main==========="+i);
        }
    }
}

4.5线程安全问题

代码：

public class ThreadSaft {
    private static String[] array = new String[5];
    private static int index=0;

    public static void main(String[] args) throws Exception{
        Runnable hello = new Runnable() {
            @Override
            public void run() {
                synchronized (array) {
                    if (array[index] == null) {
                        array[index] = "hello";
                        index++;
                    }
                }
            }
        };
        Runnable world = new Runnable() {
            @Override
            public void run() {
                synchronized (array) {
                    if (array[index] == null) {
                        array[index] = "world";
                        index++;
                    }
                }
            }
        };
        Thread t1 = new Thread(hello);
        Thread t2 = new Thread(world);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Arrays.toString(array));
    }
}

 4.6线程安全问题的解决办法

同步方法：

synchronized 返回值类型 方法名称（形参列表0）{ // 对当前对象（this）加锁

        // 代码（原子操作）

}

synchronized (Lock.b){
    System.out.println(Thread.currentThread().getName()+"获取到一根筷子");
    System.out.println("可以吃饭了");
}

 5.线程死锁

当A线程拥有锁资源a时，这时A线程需要锁资源b， 而B线程拥有锁资源b，这时B线程需要锁资源a, 这样会导致A等待B线程释放资源b, B线程等待A线程释放锁资源a。 从而二个处于永久等待。从而操作死锁。

死锁的原因：锁与锁之间有嵌套导致。

解决死锁的办法：

1. 尽量减少锁得嵌套。
2. 可以使用一些安全类。
3. 可以使用Lock中得枷锁，设置枷锁时间。

public class Lock {
    public static Object a = new Object();
    public static Object b = new Object();
}

public class Boy extends Thread{
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (Lock.a){
            System.out.println(Thread.currentThread().getName()+"获取到一根筷子");
            synchronized (Lock.b){
                System.out.println(Thread.currentThread().getName()+"获取到一根筷子");
                System.out.println("可以吃饭了");
            }
        }
    }
}


public class Girl extends Thread{
    @Override
    public void run() {
        synchronized (Lock.b){
            System.out.println(Thread.currentThread().getName()+"获取到一根筷子");
            synchronized (Lock.a){
                System.out.println(Thread.currentThread().getName()+"获取到一根筷子");
                System.out.println("可以吃饭了");
            }
        }
    }
}

 测试：

public class Test {
    public static void main(String[] args) {
        Boy b = new Boy();
        Girl g = new Girl();
        b.setName("李先生");
        g.setName("摩托哥");
        b.start();
        g.start();
    }
}

6.线程通信

都不是Thread类中，而是Object类中

等待：释放锁，进入等待队列

public final void wait()

public final void wait(long timeout)

通知：唤醒等待队列中的线程，进入到就绪队列，参与CPU的竞争

public final void notify();唤醒一个

public final void notifyAll()唤醒所有

取钱存钱：

public class BankCard01 {
    private double balance;
    private boolean flag = false;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    public synchronized void save(double money){
        if (flag==true){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //存钱
        this.balance = this.balance+money;
        System.out.println(Thread.currentThread().getName()+"存入了"+money+"现在卡里的金额为:"+this.balance);
        flag=true;
        this.notify();
    }
    public synchronized void task(double money){
        if (flag==false){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //取钱
        this.balance = this.balance-money;
        System.out.println(Thread.currentThread().getName()+"取出了"+money+"现在卡里的金额为:"+this.balance);
        flag=false;
        this.notify();
    }
}

存钱：

public class BoyTask extends Thread{
    private BankCard01 bankCard01;
    public BoyTask(BankCard01 bankCard01){
        this.bankCard01 = bankCard01;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            bankCard01.save(1000);
        }
    }
}

 取钱：

public class GirlTask extends Thread{
    private BankCard01 bankCard01;
    public GirlTask(BankCard01 bankCard01){
        this.bankCard01 = bankCard01;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            bankCard01.task(1000);
        }
    }
}

 测试：

public class Test02 {
    public static void main(String[] args) {
        BankCard01 bankCard01 = new BankCard01();
        BoyTask b = new BoyTask(bankCard01);
        GirlTask g = new GirlTask(bankCard01);
        b.setName("king");
        g.setName("马闹鸡");
        b.start();
        g.start();
    }
}

7.线程池

该池子中预先存储若干个线程对象，整个池子就是线程池

7.1线程池的作用

线程容器，可设定线程分配的数量上限

将预先创建的线程对象存入池中，并重用线程池中的线程对象

避免频繁的创建和销毁

 7.2创建线程池的方式

//Executor:线程池的根类，里面有一个方法。executor执行线程任务的方法Runnable类型的任务
//ExecutorService:线程池的子接口
//shutdown():关闭线程池，需要等待线程池中任务执行完毕后才会关闭
//shutdownNow():立即关闭线程池
//isTerminated():判断线程池是否终止了
//submit():提交任务给线程池中线程对象、Runnable和Callable类型的任务

public class Test {
    public static void main(String[] args) {
        //创建单一线程池:适应场景：队列要求线程有序执行
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建固定长度的线程池对象
        //ExecutorService executorService = Executors.newFixedThreadPool(3);
        //创建可变长度的线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        //创建延迟线程池对象
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        for (int i=0;i<5;i++){
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~~~~~~~~");
                }
            },3,TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

8.使用最原始的方式创建线程池

//int corePoolSize, 核心线程数
//int maximumPoolSize, 最大线程数
//long keepAliveTime, 空闲时间
//TimeUnit unit, 时间单位
//BlockingQueue<Runnable> workQueue 堵塞队列

public class Test02 {
    public static void main(String[] args) {
        BlockingQueue blockingQueue = new LinkedBlockingDeque(3);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,blockingQueue);
        for (int i=0;i<5;i++){
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

9.创建线程的第三种方式

实现Callable接口，它和实现Runnable接口差不多，只是该接口种的方法有返回值和异常抛出。

public class My1 implements Callable<Integer> {
    private Integer sum=0;
    @Override
    public Integer call() throws Exception {
        for (int i=1;i<=50;i++){
            sum+=i;
        }
        return sum;
    }
}

public class My2 implements Callable<Integer> {
    private Integer sum=0;
    @Override
    public Integer call() throws Exception {
        for (int i=51;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}

 测试：

public class Test {
    public static void main(String[] args) throws Exception{
        My1 m1 = new My1();
        My2 m2 = new My2();
        //自建创建线程对象并提交Callable类型的任务是比较麻烦的，需要封装到一个                    FutureTask类中，建议使用线程池来提交任务。
        //FutureTask futureTask = new FutureTask(m1);
        //Thread t1 = new Thread(futureTask);
        //t1.start();
        //System.out.println(futureTask.get());
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Future<Integer> future1 = executorService.submit(m1);
        Future<Integer> future2 = executorService.submit(m2);
        Integer integer1 = future1.get();
        Integer integer2 = future2.get();
        System.out.println(integer1+integer2);
    }
}

10.手动锁

Lock它是手动锁的父接口，它下面有很多实现类。

lock（）方法。

unlock()释放锁资源，放在finally中

Java的高级篇--多线程
Ysuhang的博客
07-19 855
线程，又称轻量级进程（LightWeightProcess）。进程中的一条执行路径，也是CPU的基本调度单位。一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程。该池子中预先存储若干个线程对象。整个池子就是线程池。......
Java高级学习笔记-1：多线程
weixin_47303191的博客
06-08 185
多线程 程序，进程，多线程 程序***(program)***是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 进程***(process)***是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程*(thread)**，进程可进一步细化为线程，是
java---线程
qq_44189274的博客
07-18 350
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程，被称为轻量进程（lightweightprocesses），进程中的一条执行路径，也是CPU的基本调度单位。一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程。进程与线程的区别1.进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。2.一个程序运行后至少有一个进程。...
Java高级——多线程
weixin_45750514的博客
08-26 189
概念：同时执行多个操作的思想，在Java中称为并发，将并发完成的每一件事称为线程。 进程的概念：每个进程都有独立的代码和数据空间，进程是资源分配的最小单位，每个独立的程序都占有一个进程。 线程的概念：表示程序的执行流程，是CPU调度执行的基本单位，同一类线程共享代码和数据空间，进程是线程的容器，即一个进程包含１＋ｎ个线程。 每一个独立的程序都是一个进程，在计算机中的所有程序都通过CPU来执行，也就是在某个时间点上，CPU只能运行一个程序，只是CPU运行速度非常快，在不同程序（进程）间切换所花费的时间特
JAVA高级之多线程
Hanshy123的博客
07-04 1216
进程：是指正在运行的程序。进程具有独立性、动态性和并发性。线程：又称轻量级进程（Light Weight Process）。线程是进程中的一条执行路径，也是CPU的基本调度单位。一个进程由一个或多个线程组成，彼此间完成不同的工作(任务)，他们同时执行，就被称为多线程。使用多线程的意义就是为了充分利用cpu资源，提高程序运行效率。
Java高级--多线程
weixin_68507438的博客
07-19 289
多线程
JAVA线程高级-线程按序交替执行
11-01
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了系统的效率和响应性。然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程...
java课件-5-多线程
01-10
"java课件-5-多线程"的主题显然聚焦于这个核心概念，旨在教授如何在Java环境中有效地利用多线程来提升程序的执行效率。 Java中的多线程允许程序同时执行多个独立的任务，这在处理I/O密集型或计算密集型任务时非常...
java线程-Java内存模型
06-17
Java线程-Java内存模型是Java并发编程中的关键概念，它描述了多个线程如何共享和访问内存资源，以及如何保证数据的一致性和安全性。Java内存模型（JMM）是Java虚拟机规范的一部分，用于定义程序中各个线程对共享变量...
awesome-java-books-多线程并发编程实战项目
最新发布
11-06
Java作为一种流行的编程语言，其强大的多线程并发处理能力一直是开发者关注的重点。在Java开发中，掌握多线程并发编程是一项核心技能，对于提高程序的性能和效率至关重要。多线程并发编程涉及到线程的创建、管理、...
Java高级-多线程
云上道人的博客
07-31 292
进程基本概念 概念 进程就是程序的一次执行过程，是系统运行程序的基本单位。操作系统在启动每一个应用时，会为每一个应用划分一块独立内存空间称之为进程。进程是操作系统中运行的一个任务（一个应用程序运行在一个进程中），包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立存在，它必须是进程的一部分。 线程基本概念 线程概念 线程与进行相似...
Java高级---多线程
shall潇の菜园
02-18 233
Java高级—多线程 一、线程的概念 再讲线程之前，那么又又又又又又又要提起进程。（这个又字看多了，好像不认识了） 进程： 程序的一次的执行过程。 线程： 操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。 二、线程的实现和方法 Thread thread = new Thread("线程1");//线程创建 System.out.println(thread.getName());//获取线程名称 thread.start(); //线程启动 thread.setPrio
Java 高级：多线程
Clawww的学习笔记
06-28 425
程序、进程、线程的基本概念 用简单的话解释： 程序就是完成特定任务的一段静态代码 进程就是程序的一次执行过程，或者说正在运行的一个程序 线程是进程的细化，是程序内部执行的一条路径 就像你打开了360安全卫士，360是程序，打开了以后电脑上就有了360的进程，360的各项功能比如查杀木马、清理电脑，开启查杀木马这样的事情就可以理解为开启了一个线程去执行了查杀木马这样的任务 线程的创建和使用 Java的多线程通过 java.lang.Thread类来体现。 ...
Java高级编程——多线程
qq_61524266的博客
05-16 794
目录Java高级编程之多线程一、基本概念：程序、进程、线程1.基本概念2.使用多线程的优点 3.何时需要多线程 二、线程的创建和使用1.线程的创建和启动 2.Thread类 3.API中创建线程的两种方式 代码演示代码演示 4.线程的调度三、线程的生命周期1.JDK中用Thread.State类定义了线程的几种状态四、线程的同步1.问题的提出 2.Synchronized的使用方法 3.代码演示使用同步代码解决实现Runnable接口的线程安全问题使用同步代码解决实现继承的线程安全问题使用同步方法解决实现
Java高级(10) 多线程
weixin_45851256的博客
06-16 287
Java高级（十）-- 多线程 基本概念 – 程序、进程、线程 程序（Program）是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象 进程（Process）是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，它有自身的产生、存在和消亡的过程，这个过程就是进程的生命周期 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程（Thread），进程可进一步细化为线程，是程序内部的一条执行路径 若一个进程同一时间并行
java高级多线程_Java高级特性系列--多线程基础
weixin_42303078的博客
02-20 328
进程：受操作系统管理的基本运行单元。360浏览器是一个进程，正在操作系统中运行的.exe都可以理解为一个进程。线程：进程中独立运行的子任务就是线程。像QQ.exe运行的时候就有很多子任务在运行，比如聊天线程/好友视频线程/下载文件线程等。多线程优点：1，资源利用率更好2，程序设计更简单3，程序相应更快多线程代价：1，有时程序设计会更复杂2，上下文切换开销大3，增加资源消耗一，多线程相关概念：线程的...
Java高级技术-多线程
漫步前行
03-03 168
Java高级面试-多线程一、多线程创建1.thread/runnable1)继承Thread类  2)实现Runnable接口   2.两种启动线程方法的区别Thread类实现了Runable接口。都需要重写里面Run方法。 区别实现Runnable的类更具有健壮性，避免了单继承的局限。Runnable更容易实现资源共享，能多个线程同时处理一个资源。 3.star方法和run方法的区别区别：调用s...
java高级特性-多线程基础1
06-16
用户要求学习Java高级特性的多线程基础教程。我们将按照以下步骤讲解：1.线程的基本概念2.创建线程的两种主要方式3.线程的生命周期4.线程的基本控制方法注意：引用中提供了两个代码示例（ThreadClassOne和Callable的...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值