Java多线程学习笔记（一）

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

线程和进程

进程是资源分配的最小单位，线程是CPU调度的最小单位
做个简单的比喻：

  1. 进程=火车，线程=车厢线程在进程下行进（单纯的车厢无法运行）
  2. 一个进程可以包含多个线程（一辆火车可以有多个车厢）
  3. 不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
  4. 同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
  5. 进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
  6. 进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
  7. 进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
  8. 进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－“互斥锁”
  9. 进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

创建多线程

方法一：继承Thread类

  1. 创建一个继承Thread类的子类
  2. 重写Thread类的run方法
  3. 创建该类的对象
  4. 通过该对象调用start方法
    我们来写一个遍历0~100的数的例子：
package com.xzc;

// 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(i);
            }
        }
    }
}
public class Test {

    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 == 1){
                System.out.println(i);
            }
        }
    }
}

输出结果
在这里插入图片描述

可以看到在main线程输出到43的时候，我们输出偶数的线程开始输出，当然，每次执行结果可能会不一样。start方法有两个作用：1.启动当前线程。2.调用当前线程的run方法。
注意两个问题：
1.我们不能通过run方法去执行，因为这样不会启动线程。
2.我们不能让一个已经start的对象再次start，会报异常。

线程有关方法

void start()

启动线程，并执行对象的run方法。

void run()

线程被执行时进行的操作。

string getName()

返回线程的名称。

void setName(string name)

设置线程的名称。

static Thread currentThread()

返回当前线程。在Thread子类中就是this，通常用于主线程和runnable实现类。

package com.xzc;

// 1. 创建一个继承Thread类的子类
class MyThread extends Thread{
    // 2. 重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class Test {

    public static void main(String[] args) {
        //3. 创建该类的对象
        MyThread t1 = new MyThread();
        t1.setName("Thread One");
        //4. 通过该对象调用start方法
        t1.start();
        Thread.currentThread().setName("Thread Main");
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

输出结果：

Thread Main:1
Thread One:0
Thread Main:3
Thread Main:5
Thread Main:7
Thread One:2
Thread Main:9
Thread One:4
Thread One:6
Thread One:8

我们也可以通过构造器去起名。

package com.xzc;

// 1. 创建一个继承Thread类的子类
class MyThread extends Thread{
    public MyThread(){

    }
    public MyThread(String name){
        super(name);
    }
    // 2. 重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class Test {

    public static void main(String[] args) {
        //3. 创建该类的对象
        MyThread t1 = new MyThread("Thread One");
        //4. 通过该对象调用start方法
        t1.start();
        Thread.currentThread().setName("Thread Main");
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

输出结果：

Thread One:0
Thread Main:1
Thread One:2
Thread Main:3
Thread One:4
Thread Main:5
Thread One:6
Thread Main:7
Thread One:8
Thread Main:9

static void yield()

释放cpu的执行权。释放之后，执行权可能会被另一个线程所拿到。

void join()

在线程A中调用线程B的join方法，此时线程A就进入阻塞状态，直到线程B执行完成，线程A才可以执行。此方法会抛出异常。

package com.xzc;

// 1. 创建一个继承Thread类的子类
class MyThread extends Thread{
    public MyThread(){

    }
    public MyThread(String name){
        super(name);
    }
    // 2. 重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class Test {

    public static void main(String[] args)  {
        //3. 创建该类的对象
        MyThread t1 = new MyThread("Thread One");
        //4. 通过该对象调用start方法
        t1.start();
        Thread.currentThread().setName("Thread Main");
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i == 19){
                try {
                    t1.join();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

我们这里分别两个线程输出0~50的偶数和奇数，看到设置main线程执行到19的时候，调用t1的join方法，之后一直执行t1，直到t1结束，才执行了main线程。
在这里插入图片描述

static void sleep(long millis)

线程休眠millis毫秒。当前线程进入阻塞状态。

package com.xzc;

// 1. 创建一个继承Thread类的子类
class MyThread extends Thread{
    public MyThread(){

    }
    public MyThread(String name){
        super(name);
    }
    // 2. 重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 0){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class Test {

    public static void main(String[] args)  {
        //3. 创建该类的对象
        MyThread t1 = new MyThread("Thread One");
        //4. 通过该对象调用start方法
        t1.start();
        Thread.currentThread().setName("Thread Main");
        for (int i = 0; i < 50; i++) {
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i == 19){
                try {
                    t1.join();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

我们这里设置线程1，是偶数的时候休眠1秒，然后主线程直接输出到19，然后t1又join进来了，然后1秒1个t1的输出，直到t1输出完，主线程才能继续执行。
在这里插入图片描述

boolean isAlive()

判断当前线程是否存活。

线程的调度

Java的调度方法：
1.同优先级线程组成先进先出队列，使用时间片策略。
2.对高优先级，使用优先调度的抢占式策略。

线程的优先级等级

MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

涉及的方法

getPriority():返回线程的优先级。
setPriority(int newPriority):设置线程的优先级。

说明

线程创建时继承父线程的优先级。
低优先级只是获得调度的概率低，不一定真的比高优先级调用后再调用。

AHawkeye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程学习笔记
Marshal丶张的博客
06-06 153
一、多线程是什么？ 介绍多线程之前要介绍线程，介绍线程则离不开进程。 进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元，一个进程一直运行，直到所有的非守护线程都结束运行后才能jie。 线程：就是进程中的一个独立控制单元，线程在控制这进程的执行。一个进程中至少有一个线程，线程不能独立存在，必须是进程的一部分。 多线程：一个进程中有多个线程...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3250
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 918
文章标题
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
Java多线程源码笔记.pdf
05-08
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统效率。在Java中，实现多线程主要有两种方式：通过继承Thread类和实现Runnable接口。Thread类提供了创建新线程的基本功能，而Runnable...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
Java内存模型
最新发布
weixin_44267758的博客
07-19 307
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 568
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 843
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 887
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java集合框架（JCF）——高效管理数据的利器
AdairRichard的博客
07-15 162
Java集合框架（Java Collections Framework，JCF）是Java提供的一套用于管理数据集合的类和接口的架构。它位于java.util包下，为开发者提供了一套丰富的接口和类来实现各种数据集合的创建、添加、删除、遍历等操作。Java集合框架是Java编程中非常重要的部分，它极大地简化了数据管理的复杂性，提高了开发效率。本文将介绍Java集合框架的基本概念、主要接口和类，以及它们之间的关系和使用场景。
【JAVA】相关程序组件
qq_44077764的博客
07-15 164
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 502
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 523
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 553
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
Java多线程编程学习笔记
"Java多线程学习总结.pdf" 在Java编程中，多线程是一种重要的概念，它允许程序同时执行多个任务，提升了程序的效率和响应性。在Java中，线程是通过`java.lang.Thread`类或者实现`java.lang.Runnable`接口来创建和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值