Java中的多线程

已于 2023-09-10 17:42:50 修改
阅读量42 收藏
点赞数
文章标签： java 开发语言
于 2023-08-09 23:23:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aahdjdb/article/details/132196075
版权

进程是程序的一次执行过程，是系统运行程序的基本单位。而线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。

创建线程的方式

1.继承Thread类

定义一个继承自Thread的类,重写run()方法,创建这个类的实例然后调用start()方法启动新线程。

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i=1;i<=5;i++){
            System.out.println("MyThread的线程输出"+i);
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        Thread t= new MyThread();
        t.start();
        for (int i=1;i<=5;i++){
            System.out.println("主线程的输出"+i);
        }
    }
}

 2.定义Runnable接口

定义一个实现Runnable接口的类,重写run()方法,然后创建Thread实例时将其作为target传入,并调用start()。 

public class MyRunnble implements Runnable {
    @Override
    public void run() {
        for (int i=1;i<=5;i++){
            System.out.println("MyThread的线程输出"+i);
        }
    }
}
public class Test1 {
    public static void main(String[] args) {
        Runnable target= new MyRunnble();
        new Thread(target).start(); // new Thread(target)得到线程对象
        for (int i=1;i<=5;i++){
            System.out.println("主线程的输出"+i);
        }
    }
}

3.利用Callable接口，FutureTask类实现

此方法可返回线程执行结果

public class CallableAndFuturetask implements Callable<String>{
    private int n;
    public CallableAndFuturetask(int n){
        this.n =n;
    }

    @Override
    public String call() throws Exception{
        int sum = 0;
        for(int i =1;i<=n;i++){
            sum+=i;
        }
        return "线程求出的和是"+sum;
    }

}
public class Test1 {
    public static void main(String[] args) throws Exception {
        Callable<String> call = new CallableAndFuturetask(100);
        FutureTask<String> f1 = new FutureTask<>(call);
        new Thread(f1).start();

        String rs = f1.get();
        System.out.println(rs);
    }
}

Thread提供了很多与线程操作相关的方法 

public class MyThread extends Thread {

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for (int i=1;i<=5;i++){
            System.out.println(t.getName()+"输出"+i);
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName("1号线程");//为线程赋名字
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread();
        t2.setName("2号线程");//为线程赋名字
        t2.start();
        System.out.println(t2.getName()); //获得子线程的名字

        Thread m = Thread.currentThread();
        m.setName("最大的线程");//为线程赋名字
        System.out.println(m.getName()); //获得主线程的名字

        for (int i =1;i<=5;i++){
            System.out.println(m.getName()+"输出"+i);
        }
    }
}

如何保证线程安全

1.同步代码块：把访问资源的核心代码上锁，每次只允许一个线程加锁后进入，以保证此线程的安全；

synchronized (同步锁){

                访问共享资源的核心代码

}

实例方法使用this关键字进行加锁，静态方法使用类名.class作为锁对象

例如为银行取钱问题的核心代码加锁

package XianchengSaft;

public class Account {
    private String IdCard;
    private double balance;
    public  Account(){

    }
    public Account(String idCard, double balance) {
        IdCard = idCard;
        this.balance = balance;
    }

    public String getIdCard() {
        return IdCard;
    }

    public void setIdCard(String idCard) {
        IdCard = idCard;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    public static void test(){
        synchronized (Account.class) {

        }
    }

    public void DrawMoney(double money){
        String name = Thread.currentThread().getName();
        synchronized (this) {
            if (this.balance>=money){
                System.out.println(name + "来取"+money+"成功");
                this.balance -= money;
                System.out.println(name + "取钱后剩余"+this.balance);
            }else{
                System.out.println(name + "来取钱，余额不足");
            }
        }
    }

    @Override
    public String toString() {
        return "Account{" +
                "IdCard='" + IdCard + '\'' +
                ", balance=" + balance +
                '}';
    }
}

2.同步方法：同步方法锁的范围更大，不利于程序的性能

修饰符 synchronized 返回值类型 方法名称(形参列表){

               操作共享资源的核心代码

}

package XianchengSaft;

public class Account {
    private String IdCard;
    private double balance;

    public Account() {

    }

    public Account(String idCard, double balance) {
        IdCard = idCard;
        this.balance = balance;
    }

    public String getIdCard() {
        return IdCard;
    }

    public void setIdCard(String idCard) {
        IdCard = idCard;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static void test() {
        synchronized (Account.class) {

        }
    }

    public  synchronized void DrawMoney(double money) {
        String name = Thread.currentThread().getName();
        if (this.balance >= money) {
            System.out.println(name + "来取" + money + "成功");
            this.balance -= money;
            System.out.println(name + "取钱后剩余" + this.balance);
        } else {
            System.out.println(name + "来取钱，余额不足");
        }
    }

    @Override
    public String toString() {
        return "Account{" +
                "IdCard='" + IdCard + '\'' +
                ", balance=" + balance +
                '}';
    }
}

3.Lock锁 

package XianchengSaft;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String IdCard;
    private double balance;
    private final Lock lk =new ReentrantLock();

    public Account() {

    }

    public Account(String idCard, double balance) {
        IdCard = idCard;
        this.balance = balance;
    }

    public String getIdCard() {
        return IdCard;
    }

    public void setIdCard(String idCard) {
        IdCard = idCard;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static void test() {
        synchronized (Account.class) {

        }
    }

    public  void DrawMoney(double money) {
        String name = Thread.currentThread().getName();
        try {
            lk.lock();
            if (this.balance >= money) {
                System.out.println(name + "来取" + money + "成功");
                this.balance -= money;
                System.out.println(name + "取钱后剩余" + this.balance);
            } else {
                System.out.println(name + "来取钱，余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock();
        }
    }

    @Override
    public String toString() {
        return "Account{" +
                "IdCard='" + IdCard + '\'' +
                ", balance=" + balance +
                '}';
    }
}

synchronized 是什么？有什么用？ 

synchronized是java中的关键字，可以保证多个线程访问资源的同步性。

synchronized修饰实例方法

synchronized void method() {
    //业务代码
}

 synchronized修饰静态方法

synchronized static void method() {
    //业务代码
}

synchronized修饰代码块

synchronized(this) {
    //业务代码
}

volatile关键字作用

  • 保证变量的可见性。如果被volatile关键字修饰的变量被一个线程修改的话，其他线程也能立马获取到变量修改后的值。
  • 禁止指令重新排序。指令排序就是编译器和处理器为了提高效率对程序优化的手段，可保证输出正确的结果，但不能保证操作顺序与代码顺序一致，因此会在多线程中出现问题，禁止了指令排序后可防止出现这一问题。

公平锁和非公平锁的区别

公平锁：锁被释放后，先申请的线程先得到锁。

非公平锁：锁被释放后，后申请的线程可能先得到锁，得到锁的机制是随机的或是按照优先级排列的。

一个帅气的程序员ovo
关注
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java 高并发多线程编程系列案例代码
01-02
Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java中多线程
07-17 1万+
所谓多线程，就是说一个应用程序有多条执行路径，每当我们打开一个应用程序的时候，就像当与打开了一个进程，而进程中执行的操作，就是线程。以迅雷为例，打开迅雷就相当于打开一个进程，下载文件的操作就是线程，多线程就是同时下载多个文件 在Java中有两种方式实现多线程分别是继承Thread类和实现Runnable接口 目录 一、继承Thread类 二、实现Runnable接口 三、继承Thread...
JAVA之多线程
maxu0808的博客
03-18 5785
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
JAVA多线程实战
超级氯化钾的博客
07-21 2803
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程中static变量总结
justlpf的专栏
09-09 2325
参考文章：Java多线程中static变量的使用 （一）静态变量：线程非安全 1、静态变量：使用static关键字定义的变量。static可以修饰变量和方法，也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 用public修饰的static成员变量...
java创建多线程的四种方式
weixin_48016395的博客
02-15 4764
java多线程的创建方式是面试经常会被问到的一个问题，因此在这里我对java创建多线程的四种方式做一个简单的归纳与总结，便于复习。 一、继承Thread类创建多线程 ① 创建一个继承于Thread类的子类。 ② 重写Thread类中的run()方法，在run()方法中实现线程需要完成的功能。 ③ 创建Thread类的子类的对象，并调用这个对象的start()方法，调用start()后会自动启动当前线程，并调用当前线程的run()方法。 ...
Java中的多线程安全问题
qq_63218110的博客
01-14 3840
本篇文章主要介绍线程安全的相关定义以及线程安全的处理方式：volatile关键字和synchronized关键字，以及JMM和Java标准库线程安全类的简单介绍。
JAVA多线程基本原理
m0_58355200的博客
04-10 1907
JAVA多线程 1. 什么是线程?线程和进程的区别? 进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当一个程序进入内存运行时，就成为一个进程。 线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。 主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。
java中实现多线程的三种方式
Mao_yafeng的博客
07-31 1万+
实现多线程的方法
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
详解Java多线程处理List数据
08-26
Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List数据的知识点。 一、什么是...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 466
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 963
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 1002
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1034
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 547
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
Java中多线程的使用
08-07
### 回答1： Java 中的多线程可以通过创建 Thread 类的实例来实现。具体步骤如下： 1. 创建一个实现 Runnable 接口的类，该类实现 run() 方法。 ```java public class MyRunnable implements Runnable { public void run() { // 执行线程的操作 } } ``` 2. 创建一个 Thread 实例，并将实现了 Runnable 接口的类作为构造函数的参数。 ```java MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); ``` 3. 启动线程。 ```java thread.start(); ``` 此外，还可以通过继承 Thread 类来实现多线程。具体步骤如下： 1. 创建一个继承自 Thread 类的类，重写 run() 方法。 ```java public class MyThread extends Thread { public void run() { // 执行线程的操作 } } ``` 2. 创建 MyThread 的实例。 ```java MyThread myThread = new MyThread(); ``` 3. 启动线程。 ```java myThread.start(); ``` 在多线程的使用中，需要注意线程安全的问题，比如共享变量的访问、同步操作等。可以使用 synchronized 关键字或者 Lock 接口来保证线程安全。 ### 回答2： 在Java中，多线程的使用是指程序同时运行多个线程，每个线程执行自己的任务。Java中多线程的使用可以带来以下几点好处： 1. 提高程序的效率：多线程可以对多个任务进行并发处理，提高程序的运行效率。例如，可以将网络请求和UI界面分别放在两个不同的线程中，这样即使网络请求比较耗时，UI界面也能进行响应，不会出现界面假死的情况。 2. 充分利用系统资源：多线程可以充分利用系统的处理器资源，提高系统的利用率。在多核处理器上运行多个线程，可以让每个核心都得到充分利用，提高系统的整体性能。 3. 实现异步编程：多线程可以实现异步编程，即一个线程执行后续操作，不需要等待另一个线程的完成。这样可以提高程序的响应速度。例如，可以使用多线程来进行文件下载，下载过程中可以同时进行其他操作。 4. 处理复杂的并发情况：在一些需要处理多个并发操作的场景中，多线程可以提供更好的解决方案。例如，在并发访问共享资源的情况下，使用线程锁可以保证对共享资源的安全访问，避免数据冲突和一致性问题。 Java中使用多线程可以通过创建Thread类的实例或者实现Runnable接口来实现。通过继承Thread类来创建线程，需要重写run方法，在run方法中定义线程要执行的任务。通过实现Runnable接口来创建线程，需要实现run方法，并将实现了Runnable接口的对象作为参数传递给Thread类的构造方法。 总之，Java中多线程的使用使得程序可以同时执行多个任务，提高了程序的效率和用户体验，并且能够处理复杂的并发情况。但需要注意多线程的安全性和线程之间的协作，避免出现数据冲突和一致性问题。 ### 回答3： Java中多线程的使用是指在一个程序中同时执行多个任务或者同时处理多个请求。多线程可以提高程序的并发性和响应性，可以将耗时的操作和任务分配给不同的线程来执行，从而提高程序的运行效率。 在Java中，多线程的使用主要依靠Thread类或者实现Runnable接口来创建线程。可以通过继承Thread类创建一个线程类，并重写run方法，在run方法中定义需要执行的任务；也可以实现Runnable接口，创建一个Runnable对象，然后将该对象作为参数传递给Thread类的构造方法，创建一个线程对象。 使用多线程的好处是可以充分利用处理器的多核特性，同时进行多个任务，提高程序的运行效率。多线程还可以提高程序的响应性，当程序中有耗时的操作时，可以将其放在一个独立的线程中执行，防止主线程被阻塞，提高用户体验。 然而，多线程的使用也存在一些问题。首先是线程安全问题，多个线程同时访问共享资源可能导致数据不一致或者数据损坏。为解决这个问题，可以使用同步机制，如synchronized关键字或Lock接口，保证在同一时间只有一个线程能够访问共享资源。其次，多线程的创建和销毁会消耗系统资源，如果线程数量过多，可能会影响系统性能。因此，在使用多线程时应该合理控制线程的数量。另外，线程之间的协调和通信也是一个值得关注的问题，可以使用wait、notify、join等方法来实现线程间的协作。 总之，Java中多线程的使用可以提高程序的并发性和响应性，但需要注意线程安全、资源消耗以及线程协调和通信等问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一个帅气的程序员ovo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值