【Java】线程

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

线程

概念

线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

进程像是一个软件，线程是该软件的执行路径。

线程调度

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的为抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步

排队执行 , 效率低但是安全。

异步

同时执行 , 效率高但是数据不安全。

并发与并行

并发

指两个或多个事件在同一个时间段内发生。

并行

指两个或多个事件在同一时刻发生（同时发生）

并发的关键是你有处理多个任务的能力，不一定要同时。
并行的关键是你有同时处理多个任务的能力。
它们最关键的点就是：是否同时。

如何在Java中实现多线程

线程类 Class Thread

继承Thread

继承Thread的子类就是一个线程类。继承Thread之后，我们需要重写run方法。

run方法：
线程要执行的任务方式。
run方法里的代码是一条新的执行路径
该执行路径的触发方式不是调用run方法，而是同过Thread对象的start()来启动任务。

子线程调用的方法都在子线程中运行。
每个线程都拥有自己的栈空间，公用一份堆内存。

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

// Test.java
public class Test {
    public static void main(String[] args) {
        MyThread m = new MyThread();
        m.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }
    }
}

输出样例：

main0
MyThread0
main1
MyThread1
main2
MyThread2
main3
MyThread3
main4
MyThread4
main5
MyThread5
main6
MyThread6
MyThread7
MyThread8
main7
MyThread9
main8
main9

Thread匿名内部类实现

public class Test {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("匿名内部类实现" + i);
                }
            }
        }.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }
    }
}

实现Runnable

实现Runnable与继承Thread相比有如下优势:

  1. 通过创建任务，然后给线程分配的方式来实现的多线程．更适合多个线程同时执行相同任务的情况.
  2. 可以避免单继承所带来的局限性.
  3. 任务与线程本身是分离的，提高了程序的健壮性.
  4. 线程池技术，接受Runnable类型的任务，不接收Thread类型的线程.
// MyRunnable.java
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyRunnable"+i);
        }
    }
}

//Test.java
public class Test {
    public static void main(String[] args) {
    	//1. 创建任务对象
        MyRunnable r = new MyRunnable();
        //2. 创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3. 执行这个线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }
    }
}

Class Thread

常用构造方法

ConstructorDescription
Thread()Allocates a new Thread object.
Thread(Runnable target)Allocates a new Thread object o that it has target as its run object.
Thread(Runnable target, String name)Allocates a new Thread object so that it has target as its run object, has the specified name as its name.
Thread(String name)Allocates a new Thread object has the specified name as its name.

常用方法

Modifier and TypeMethodDescription
longgetId()Returns the identifier of this Thread.
StringgetName()Returns this thread’s name.
intgetPriority()Returns this thread’s priority.
voidsetPriority(int newPriority)Changes the priority of this thread. (Parameters: MIN_PRIORITY, NORM_PRIORITY, MAX_PRIORITY)
voidstart()Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
voidstop()This method is utdated and unsafe. Don’t use.
static voidsleep(long millis)Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.
static voidsleep(long millis, int nanos)Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds plus the specified number of nanoseconds, subject to the precision and accuracy of system timers and schedulers.
voidsetDaemon(boolean on)Marks this thread as either a daemon thread or a user thread.

Daemon threads:
线程分为守护线程（守护用户线程）和用户线程
所有用户线程全部结束，它们的守护线程才会结束结束。

  1. getName() :

    Example: Get the name of current thread
    System.out.println(Thread.currentThread().getName());

  2. sleep() :

    Example: Sleep for a second
    Thread.sleep(1000);

补充

线程堵塞和中断

线程堵塞

所有比较消耗时间的操作。

线程中断

一个线程的是一个独立的执行路径，它是否应该结束由其自身决定。

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 给线程t1添加中断标记
        t1.interrupt();

    }
    
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 中断标记只会进入catch块
                    //e.printStackTrace();
                    // 如果没有死亡操作，线程不会死亡
                    return; //return结束线程
                }
            }
        }
    }
}

线程不安全

多个线程同时执行（争抢）同一个数据时，线程不安全。

如何处理线程不安全问题

要让线程排队执行，加锁执行。有以下三种方法：

方法格式描述
同步代码块(关键字)synchronized(锁对象){}隐式锁，多个线程的锁对象必须唯一
同步方法(修饰符)synchronized 返回类型 方法名(){}隐式锁，谁调用该方法谁就是锁对象
显示锁ReentrantLock 类的 lock()/unlock() 方法显式锁，有程序员决定在那开启/关闭锁
方法一：同步代码块（关键字）

格式： synchronized(同一个锁对象){ }

public class Test {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    
    static class Ticket implements Runnable{
        private int count = 10;
        private Object o = new Object();
        
        @Override
        public void run() {
            while(true) {
                synchronized (o) {
                    if(count>0) {
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                    }
                    else break;
                }
            }
        }
    }
}
方法二：同步方法（修饰符）

以下两种方法是等价的：

public synchronized void sale() { // 锁住this
    count --;
} // 解锁

 public void sale() {
    synchronized(this) { // 锁住this
        count --;
    } // 解锁
}

对于static方法，是没有this实例的，因为static方法是针对类而不是实例。但是我们注意到任何一个类都有一个由JVM自动创建的Class实例，因此，对static方法添加synchronized，锁住的是该类的Class实例。

public class Test{
    public static void sale() {
        synchronized(Test.class) {
            ...
        }
    }
}

测试代码：

import java.util.TimerTask;

public class Test {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            while(true) {
                boolean flag = sale();
                if(!flag) break;
            }
        }

        public synchronized boolean sale(){
            if(count>0) {
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                return true;
            }
            return false;
        }
    }
}
方法三：显示锁 Lock 子类 ReentrantLock
public class Test {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        private int count = 10;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while(true) {
                l.lock();
                if(count>0) {
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票："+count);
                }
                else break;
                l.unlock();
            }
        }
    }
}

公平锁和非公平锁

公平锁

先到先得

用法：显示锁 l：fair 参数为 true 表示公平锁
Lock l = new ReentrantLock(true);

非公平锁

（一起解锁，然后）同时抢

线程死锁

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockB) { // 获得lockB的锁
        this.another -= m;
        synchronized(lockA) { // 获得lockA的锁
            this.value -= m;
        } // 释放lockA的锁
    } // 释放lockB的锁
}

当两个线程分别执行add()和dec()方法时：

  • 线程1：进入add()，获得lockA；
  • 线程2：进入dec()，获得lockB。

随后：

  • 线程1：准备获得lockB，失败，等待中；
  • 线程2：准备获得lockA，失败，等待中。

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

多线程通信问题

多线程通信问题也可以理解为生产者与消费者的问题，多线程互交。

生产者在生产时，消费者没有在消费
消费者在消费时，生产者没有在生产

Object类的方法：

Modifier and TypeMethodDescription
voidnotify()Wakes up a single thread that is waiting on this object’s monitor.
voidnotifyAll()Wakes up all threads that are waiting on this object’s monitor.
voidwait()Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object.

this.notifyAll();
this.wait();

线程的六种状态


new：线程创建，未启动
Waiting：无限等待

是派大大欣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】多线程
XiaoYabeI的博客
08-25 160
一、基本概念：程序、进程、线程 1.基本概念 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域（想象成一座房子）
Java线程
sunyingboaini的博客
06-20 1万+
线程的使用
探索Java线程副本技术：深入理解与实践ThreadLocal
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 2万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
Java线程阻塞
qq_43966957的博客
12-06 4779
Java线程阻塞
ｊａｖａ线程
09-28
程研究了线程的基础知识— 线程是什么、线程为什么有用以及怎么开始编写使用线程的简单 程序。 我们还将研究更复杂的、使用线程的应用程序的基本构件— 如何在线程之间交换数据、如何控制 线程以及线程如何互相通信...
java线程分析工具TDA
06-21
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
Java 线程
06-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2219492
详解Java线程堆栈
08-28
Java线程堆栈详解 Java线程堆栈是一种强大的诊断工具，能够帮助开发者快速定位多线程应用程序中的问题。通过分析线程堆栈，可以找到系统中各种问题的根源，如系统无缘无故CPU过高、系统挂起、系统运行越来越慢、...
深入理解java线程通信
08-25
深入理解 Java 线程通信 Java 线程通信是 Java 编程中一个非常重要的概念，它可以使得多个线程之间能够相互通信和协作，从而实现更加复杂的任务。下面我们将深入理解 Java 线程通信的机制和实现方式。 一、等待...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1178
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 475
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 230
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1936
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1327
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 993
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
最新发布
Sakurapaid的博客
07-25 230
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 846
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 711
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值