Java 高级开发技术学习笔记之多线程

最新推荐文章于 2024-05-23 17:45:07 发布
最新推荐文章于 2024-05-23 17:45:07 发布
阅读量217 收藏 2
点赞数 2
分类专栏： Java 文章标签： java 编程语言 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44195757/article/details/108011524
版权

暑假期间，个人对一些未来研究生阶段可能会常用的编程技术进行重新一轮的系统复习和学习，及希望能够查缺补漏，有所提升。本文也是作为复习和学习过程中的笔记，用于长久的记录。不排除其中可能含有部分疏漏和错误，如有发现，希望各位能够批评指正，谢谢。

一、多线程概述

概述

  • 每个进程有独立的方法区、堆空间、虚拟机栈和程序计数器。
  • 一个进程可能拥有多个线程。
  • 每个线程有独立的虚拟机栈和程序计数器，但是一个进程下的多线程共享方法区和堆空间。

线程的优先级

  • 线程存在优先级，优先级越高，CPU将资源分配到该线程的可能性越大，但是这并不意味着高优先级的线程一定先运行。
  • Java线程优先级分为十个级别，从1~10（整数），默认是5。
    • 最低优先级Thread.MIN_PRIORITY（1）
    • 默认优先级Thread.NORM_PRIORITY（5）
    • 最高优先级Thread.MAX_PRIORITY（10）

二、线程的生命周期

  • 线程的状态分为五种。
    • 新建：完成线程创建。
    • 就绪：线程可以随时开始运行，但是尚未处于运行状态。
    • 运行：线程正在运行。
    • 死亡：线程完成运行。
    • 阻塞：线程被限制无法运行，只能通过其他命令使其重新进入就绪/运行状态。

三、创建多线程的方法

创建Thread子类

  • 创建Thread子类，并重写run()方法。
package com.katus.thread;

/**
 * 创建多线程的方式 1: 创建Thread子类
 * @author katus
 * @version 1.0, 2020-08-09
 */
class MyThread extends Thread {   // 因为要求继承Thread类 导致本类不能是其他类的子类
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {   // 此线程执行的操作
        try {
            sleep(1000);   // 本线程阻塞1000ms
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                System.out.println(this.getName() + ":" + i);
            }
//            if (i % 20 == 0) {
//                Thread.yield();   // 释放当前线程CPU的执行权, 但是有可能又被CPU分配到了
//            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Thread.currentThread().setName("Thread-main");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);   // 设置最低优先级
        // 创建线程对象
        MyThread t1 = new MyThread("Thread-1st");
        t1.setPriority(Thread.MAX_PRIORITY);   // 设置最高优先级
        // 开始执行线程, 主线程继续
        // t1.setName("Thread-1st");
        t1.start();   // 启动当前线程并调用当前线程的run()
        // t1.run();   // 错误的启动线程的方法
        // t1.start();   // 不能让已经start的线程再次start
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            if (i == 30) {
                try {
                    t1.join();   // 调用后本线程阻塞, t1线程执行至结束, 本线程取消阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(t1.isAlive());   // 判断线程是否存活 如果执行完毕即不存活
    }
}

创建Runnable接口的实现类

  • 创建一个类实现Runnable接口，重写其中的run()方法。
  • 本方法的优势在于创建的类可以作为其他有意义自定义类的子类，（相对于上一种方法）不必受单继承的限制。
package com.katus.thread;

/**
 * 创建多线程的方式 2: 实现Runnable接口
 * @author katus
 * @version 1.0, 2020-08-10
 */
class MThread implements Runnable {
    // 实现Runnable接口中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        MThread mThread = new MThread();   // 创建实现类对象
        Thread t1 = new Thread(mThread);   // 构造线程
        t1.start();   // 启动线程

        // 再次启动一个线程
        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

创建Callable接口的实现类

  • 创建一个类，实现Callable接口，重写其中的call()方法。
  • 该方法要求Java 5以上版本。
  • 本方法的优势在于创建的线程允许抛出异常，允许有返回值，同时支持泛型。
package com.katus.thread;

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

/**
 * 创建多线程的方式 3: 实现Callable接口 (Java5 新特性)
 * @author katus
 * @version 1.0, 2020-08-10
 */
// 创建Callable接口的实现类
class NumThread implements Callable {
    // 重写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 ThreadTest2 {
    public static void main(String[] args) {
        // 创建Callable实现类的对象
        NumThread numThread = new NumThread();
        // 通过Callable实现类对象构建FutureTask类的对象
        FutureTask futureTask = new FutureTask(numThread);
        // 通过FutureTask类对象构建Thread类的对象 即构建线程
        new Thread(futureTask).start();
        try {
            // 下方法的返回值即为Callable实现类中call方法的返回值
            Object sum = futureTask.get();
            System.out.println("sum = " + sum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

  • 通过Executors类创建线程池，设定线程池参数，通过线程池提交/执行多线程。
  • 该方法要求Java 5以上版本。
  • 优势在于方便进行线程管理和调度。
package com.katus.thread;

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

/**
 * 创建多线程的方式 4: 使用线程池 (Java5 新特性)
 * @author katus
 * @version 1.0, 2020-08-10
 */
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 NumberThread1 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 ThreadTest3 {
    public static void main(String[] args) {
        // 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);   // ExecutorService 是返回对象实现的接口

        System.out.println(service.getClass());   // 验证实际返回的对象的类

        // 可选设置线程池的属性
        ThreadPoolExecutor executor = (ThreadPoolExecutor) service;   // ThreadPoolExecutor 才是实际返回的对象
        executor.setCorePoolSize(15);
        executor.setMaximumPoolSize(12);
        // executor.setKeepAliveTime(...);

        NumberThread numberThread = new NumberThread();
        service.execute(numberThread);   // 接受Runnable实现类

        NumberThread1 numberThread1 = new NumberThread1();
        service.submit(numberThread1);   // 接受Callable/Runnable实现类

        // 关闭线程池
        service.shutdown();
    }
}

四、线程安全

同步代码块

  • 一个被synchronized关键字修饰的代码块，需要传入一个Object对象作为同步监视器，该Object对象作为是否需要限制的标志，即需要同一个同步监视器的代码块中的代码同时只能有一个线程在运行。
  • 同步代码块执行完成之后，相应的同步监视器会被释放。
package com.katus.thread;

/**
 * 线程安全之同步代码块
 * @author katus
 * @version 1.0, 2020-08-10
 */
class TicketSaleWindow implements Runnable {
    private int ticket;
    private final Object lock = new Object();

    public TicketSaleWindow(int number) {
        ticket = number;
    }

    @Override
    public void run() {
        while (true) {
            // 同步代码块 接受同步监视器（锁）任何类的对象 要求多线程的锁是同一个对象
            synchronized (lock) {   // synchronized (this) 最简单的写法   // synchronized (TicketSaleWindow.class)
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}

public class TicketSale {
    public static void main(String[] args) {
        TicketSaleWindow window = new TicketSaleWindow(250);
        Thread t1 = new Thread(window), t2 = new Thread(window), t3 = new Thread(window);
        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法

  • 同步方法就是具有同步功能的方法，相当于整个方法体都是同步的，方法声明被synchronized关键字修饰。
  • 同步方法也是需要同步监视器的，但是是隐性的。
    • 静态同步方法，同步监视器是类名.class。
    • 非静态同步方法，同步监视器是this。
  • 同步方法体执行完成之后会释放同步监视器。
package com.katus.thread;

/**
 * 线程安全之同步方法 本质上就是把同步代码块变成了整个方法
 * @author katus
 * @version 1.0, 2020-08-10
 */
class TicketSaleWindow2 implements Runnable {
    private int ticket;

    public TicketSaleWindow2(int number) {
        ticket = number;
    }

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

    /*要注意同步方法在继承Thread类的方式下要改写成静态方法才能获得线程安全!!! 同步监视器为TicketSaleWindow2.class*/
    private synchronized void show() {   // 非静态同步方法的默认监视器是this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + ticket--);
        }
    }
}

public class TicketSale2 {
    public static void main(String[] args) {
        TicketSaleWindow2 window = new TicketSaleWindow2(250);
        Thread t1 = new Thread(window), t2 = new Thread(window), t3 = new Thread(window);
        t1.start();
        t2.start();
        t3.start();
    }
}

Lock锁

  • ReentrantLock类对象，顾名思义，其lock()方法和unlock()方法成对使用，lock()方法调用后，其他线程都无法执行，只有等unlock()方法调用之后才会解锁。
  • 该方法要求Java 5以上版本。
package com.katus.thread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程安全之Lock锁 (Java5新特性)
 * @author katus
 * @version 1.0, 2020-08-10
 */
class TicketSaleWindow3 implements Runnable {
    private int ticket;
    private final ReentrantLock lock = new ReentrantLock();

    public TicketSaleWindow3(int number) {
        ticket = number;
    }

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

public class LockTest {
}

五、线程通信

  • notify() notifyAll() wait() 只能用在同步方法和同步代码块中。
  • 三个方法的调用者必须是当前同步代码块或者同步方法的同步监视器。
  • 三个方法是定义在Object类中的 所有的对象均有资格调用。
package com.katus.thread;

/**
 * 线程通信
 * @author katus
 * @version 1.0, 2020-08-10
 */
class NumberPainter implements Runnable {
    private int number;

    public NumberPainter() {
        this(0);
    }

    public NumberPainter(int number) {
        this.number = number;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                // 一旦执行此方法 会有一个wait中的阻塞线程被唤醒(选取其中优先级高的线程)
                notify();   // this.notify();
                // 一旦执行此方法 全部wait中的阻塞线程被唤醒
                // notifyAll();
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number++);
                } else {
                    break;
                }
                try {
                    // 一旦执行此方法 本线程立刻阻塞 同时释放同步监视器
                    wait();   // this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ThreadCommunicationTest {
    public static void main(String[] args) {
        NumberPainter numberPainter = new NumberPainter();
        Thread t1 = new Thread(numberPainter), t2 = new Thread(numberPainter);

        t1.start();
        t2.start();
    }
}
katus
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE高级开发之多线程
近未来
08-08 229
1. 进程与线程的概念 进程：操作系统中一个程序的执行周期 线程：一个程序同时执行多个任务。通常来讲，每一个任务就称为一个线程。 进程与多线程比较： 与进程相比，线程更加的“轻量级”，创建、撤销一个线程比启动、撤销一个进程开销要小的多。一个进程中的所有线程共享此进程的所有资源。 没有进程就没有线程，进程一旦终止，其内的线程将不复存在。 进程是操作系统资源调度的基本单位，进程可以独享资源；线程需要...
Java 学习多线程笔记
cyberscutoid的博客
03-07 2183
多线程的目的 为了更合理的利用cpu资源 多线程的概念 一个进程运行时产生多个线程 并行与并发 并行：多个cpu实例同时执行一段逻辑 并发：通过cpu调度算法，让程序看上去像是同时执行，提高程序运行效率。 线程安全 线程安全：在并发的前提下，该代码经过多线程的使用，线程的调度顺序不影响产生的结果。 线程不安全：与线程安全相反，线程的调度顺序影响最终的结果 同步：通过人为的控制与调度，保证共享资源的多线程访问成为线程安全，确保结果的准确。 调度：1.分时 2.抢占
java高级编程——多线程（一）之实现多线程
晃在云淡风轻
05-29 1540
文章目录线程与进程并行与并发JVM虚拟机是多线程的吗多线程实现继承Thread类实现Runnable接口两种方法的区别与联系利用Callable接口实现多线程 线程与进程 线程和进程一样，都是实现并发的一个基本单位。 线程是依赖进程存在的。先来说进程，进程就是程序的一次动态执行过程。通俗来讲，进程就是正在运行的程序，它是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。 ...
Java高级编程——多线程（基本概念+线程的创建及应用）
ou_yang_mu_ling的博客
08-28 423
目录1、基本概念：程序、进程、线程1.1程序（program）1.2进程（process）1.3线程（thread）1.4并行与并发并行并发1.5使用多线程的优点1.6多线程的应用场景2、线程的创建和应用（重点）2.1java.lang.Thread2.1.1通过继承Thread创建线程2.1.2创建过程中的两个问题2.1.2.1问题一：不能直接调用run()方法来执行线程2.1.2.2 问题二：不能对同一线程执行两次start()2.1.3 创建Thread的匿名子类2.1.4Thread的常用方法se
面试宝典-java高级开发-多线程
qq_32756409的博客
06-11 123
一.多线程的优势: 多线程能带动cpu的处理效率，能使代码中的方法开启多个cpu运行，使运行速度更快。 二.多线程的三种实现方式： 1.继承java.lang.Thread, 重写run()方法 public class thisThread extends Thread { @Override public void run() { System.out.println("这是一个多线程："+Thread.cu...
Java高级开发必备-多线程开发
xujunfei520的博客
10-30 219
Java高级开发必备-多线程开发 文章目录Java高级开发必备-多线程开发线程池ExecutorServiceExecutors创建线程池ThreadPoolExecutor自定义Callable创建线程Queue队列BlockQueueDelayQueueConcurrentLinkedQueue等待通知wait|notify自定义线程池ThreadLocalLock锁ReentrantLock...
《Java多线程编程核心技术》学习笔记（1）
洋YANG的博客
02-23 1万+
一、实现多线程的编程方式 （1）继承Thread类 public class MyThread extends Thread { @Override public void run() { super.run(); System.out.println(&amp;amp;amp;amp;quot;MyThread&amp;amp;amp;amp;quot;); } } public class Run { publi
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
qq_35716689的博客
03-16 5万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
《Java多线程编程核心技术》学习笔记（一）——Java的多线程
benhuo931115的博客
12-15 1109
Java多线程进程：系统进行资源分配和调度的一个独立单位 线程：在进程中独立运行的子任务使用多线程：多线程是异步的线程启动顺序与start()执行顺序无关非线程安全：指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况，进而影响程序的执行流程。解决方法：在run方法前加入synchronized关键字，使多个线程在执行run方法时，以排队的方式进行处理public cl
java技术学习笔记以及互联网面试常见题.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
Java并发编程学习笔记 pdf 多线程编程
08-20
Java并发编程学习笔记，研究JAVA并发多线程编程的一本教程，使用并发技术可以开发出并行算法，充分利用多处理器的计算能力，避免硬件资源浪费。目前，在JAVA并发编程方面的论述系统且内容详实的技术资料不太多，Java...
Java中线程同步和线程协作学习笔记
05-27
java核心技术-多线程的概念及多线程单例设计模式的应用-懒汉模式、饿汉模式、优化懒汉
java内部学习笔记.docx
02-18
Java技术基础 4 1.1编程语言 4 1.2 Java的特点 4 1.3 Java开发环境 4 1.4 Java开发环境配置 5 1.5 Linux命令与相关知识 5 1.6 Eclipse/Myeclipse程序结构 6 Java语言基础 7 2.1基础语言要素 7 2.2八种基本数据类型 7...
java多线程笔记
01-14
Java线程：概念与原理 2 一、操作系统中线程和进程的概念 2 二、Java中的线程 3 三、Java中关于线程的名词解释 3 四、线程的状态转换和生命周期 4 Java线程：创建与启动 7 Java线程：线程名称的设定及获取 10 Java...
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1118
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring Bean Map之舞
m0_51176516的博客
05-23 198
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 264
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
Java高级面试精粹：问题与解答集锦（一）
最新发布
Layla_c的博客
05-23 726
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
java后端开发学习笔记
10-20
Java后端开发是指使用Java语言进行服务器端编程，主要包括Java Web开发、Java框架开发、数据库开发等。如果你想学习Java后端开发，可以从以下几个方面入手： 1.计算机基础：学习计算机基础知识，包括计算机组成原理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值