多线程java

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量1k 收藏 14
点赞数 22
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64491897/article/details/137696989
版权
本文详细介绍了Java中多线程的创建方式（继承Thread、实现Runnable和Callable接口），线程池的使用，以及同步机制（乐观锁与悲观锁）的应用。重点讨论了如何启动线程、任务返回结果和处理线程安全问题。
摘要由CSDN通过智能技术生成

多线程的创建

前两种方法无法返回直接结果,而有的线程执行完毕后需要返回结果

方式一:java是通过java.lang.Thread类的对象来代表线程的
  • 启动线程必须调用strat方法,不是调用run方法
  • 不要把主线程任务放在启动子线程之前
//1.让子类继承Thread线程类
public class MyThread extends Thread{
    //2.必须重写Thread类的run方法
    @Override
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread线程输出:"+i);
        }
    }
}

public class ThreadTest1 {
    //main
    public static void main(String[] args) {
        //3.创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        //4.启动线程
        t.start();
    }
}
方式二:实现Runnable接口
  • 优点:任务类只是实现接口,可以继续继承其他类,实现其它接口,扩展性强
//1.实现Runnable接口
public class MyRunnable implements Runnable{
    //2.重写run方法
    @Override
    public void run() {
        //3.线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:"+i);
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        //4.创建任务对象
        Runnable target = new MyRunnable();
        //5.把任务对象交给一个线程处理
        new Thread(target).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}
线程创建方式二的匿名内部类写法
  1. 可以创建Runable的匿名内部类对象
  2. 再交给Thread线程对象
  3. 在调用线程对象的Strat()启动线程
public class ThreadTest2_2 {
    public static void main(String[] args) {
        //1.直接创建Runnable接口的匿名内部类形式(任务对象)
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1输出:"+i);
                }
            }
        };
        new Thread(target).start();

        //简化形式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2输出:"+i);
                }
            }
        }).start();

        //再次简化
        new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3输出:"+i);
                }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:"+i);
        }
    }
}
方式三:实现Callable接口
  • JDK5.0提供了Cabble接口和FutureTask类来实现
  • 可以返回线程执行完毕后的结果

过程

  1. 定义一个类实现Callable接口,重写Call方法,封装要做的事,和要返回的数据结果
  2. 把Callable类型的对象封装成FutureTask(线程任务对象)
  3. 把线程任务对象交给Thread对象
  4. 调用start方法启动线程
  5. 线程执行完毕后,通过FutureTask对象的get方法去获取线程任务执行的结果
public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        //3.创建一个Callable对象
        Callable<String> callable  = new MyCallable(100);
        //4.把Callable对象封装成一个FutureTask对象
        //未来任务对象
        //1.是一个任务对象,实现了Runnable接口
        //2.可以在线程执行完毕之后,用未来任务对象调用get方法获取线程完毕后的结果
        FutureTask<String> futureTask = new FutureTask(callable);

        new Thread(futureTask).start();

        //6.获取线程执行完毕后的结果
        System.out.println(futureTask.get());
    }
}

//1.让这个类实现Callable接口
public class MyCallable implements Callable {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法
    //求1-n的和

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

线程的方法

public class MyThread extends Thread{
    public MyThread(String name) {
        super(name);

    }

    @Override
    public void run(){
        Thread m = Thread.currentThread();

        for (int i = 0; i < 3; i++) {
            System.out.println(m.getName()+"子线程输出:"+i);
        }
    }
}

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

        //构造器设置名字
        Thread t2 = new MyThread("二号线程");
        t2.start();
        System.out.println(t2.getName());

        //主线程对象的名字
        Thread m = Thread.currentThread();//那个线程执型它,他就会得到哪个对象
        System.out.println(m.getName());

        for (int i = 0; i < 4; i++) {
            System.out.println("main线程输出:"+i);
        }
    }
}

//sleep  join   的作用
public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 5; i++) {
            //到3的时候休眠五秒
            if(i==3){
                Thread.sleep(5000);
            }
            System.out.println(i);
        }

        //join方法的作用:让调用这个方法的线程先执行完
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();
        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();
        Thread t3 = new MyThread("3号线程");
        t3.start();
        Thread t4 = new MyThread("4号线程");
        t4.start();

    }
}

线程安全问题

加锁:每次只允许一个线程加锁,加锁后才能访问进入,访问完毕后自动解锁,然受其他线程才能在加锁进来

同步代码块
synchronized (同步锁){
    访问共享资源的核心代码
}
同步锁的注意事项
  • 对于当前同时执行的线程来说,同步锁必须是同一把(同一个对象),否则会出bug
  • 建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象
  • 对于静态方法使用字节码(类名.class)对象作为锁对象
public class Account {
    private String id;//卡号
    private double money;//余额

    public Account() {
    }

    public Account(String id, double money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;

    }

    public void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();
        //1判断余额是否足够
        //this 正好可以代表共享资源
        synchronized (this) {
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        }
    }
}

public class DrawThread extends Thread{
    private Account acc;
    public  DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run(){
        //取钱
        acc.drawMoney(100000);
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //创建一个账户对象
        Account acc = new Account("123456",100000);
        //2.创建两个线程分别代表小明小红,再去同一个账户中取钱
        new DrawThread(acc,"小明").start();//小明
        new DrawThread(acc,"小红").start();//小红
    }
}
同步方法

作用:把访问共享核心资源的核心方法给上锁,以此保证线程安全

  • 如果是实例方法,同步方法默认使用this作为所得对象
  • 如果方法是静态方法,同步方法默认使用类名.class作为所得对象
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
 public synchronized void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();

        //1判断余额是否足够
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
    }
lock锁
package d4_thread_synchronized;

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

public class Account {
    private String id;//卡号
    private double money;//余额
    //创建了一个锁对象
    private final Lock lk = new ReentrantLock();

    public Account() {
    }

    public Account(String id, double money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;

    }

    public void drawMoney(int i) {
        //先搞清楚是谁来取钱
        String name = Thread.currentThread().getName();

        lk.lock();
        try {
            //1判断余额是否足够
            if(this.money>=i){
                System.out.println(name+"来取钱"+i+"成功");
                this.money-=i;
                System.out.println(name+"取钱后,余额是"+this.money);
            }else{
                System.out.println(name+"来取钱:余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lk.unlock();
        }
        
    }
}

线程池

计算密集型的任务:核心线程数量 = CPU的核数 + 1

IO密集型的任务: 核心线程数量 = CPU的核数 * 2

创建线程池对象
1. 方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

临时线程什么时候创建

  • 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程

什么时候开始拒绝新任务

  • 核心线程和临时线程都在忙,任务队列也满了,新的任务过来时才会开始拒绝任务
public ThreadPoolExecutor(int corePoolSize,  //指定线程池的核心线程数量
                          int maximumPoolSize,  //指定线程池的最大线程数量
                          long keepAliveTime,  //制定临时线程的存活时间
                          TimeUnit unit,  //指定临时线程的存活的时间单位(秒,分,时,天)
                          BlockingQueue<Runnable> workQueue,  //指定线程池的任务队列
                          ThreadFactory threadFactory,  //指定线程池的线程工厂
                          RejectedExecutionHandler handler  //指定线程池的任务拒绝策略(线程都在忙,任务队列也满了的时候,新任务来了该怎么处理)
                         ) {}
ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,
                                              new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                                              new ThreadPoolExecutor.AbortPolicy());
2. 方式二:使用Executors(线程池的工具类)调用方法返回特点的线程池对象
package d6_threadPoolExecutor;

import d1_create_thread.MyCallable;

import java.util.concurrent.*;

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {

        //通过Executors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(3);

        //使用线程处理Callable任务
        Future<String> f1 = pool.submit(new d1_create_thread.MyCallable(100));
        Future f2 = pool.submit(new d1_create_thread.MyCallable(200));
        Future f3 = pool.submit(new d1_create_thread.MyCallable(300));
        Future f4 = pool.submit(new d1_create_thread.MyCallable(400));
        Future f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());


    }
}
线程池处理Runnable任务
package d6_threadPoolExecutor;

import java.util.concurrent.*;

public class ExecutorTest1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        MyRunnable target = new MyRunnable();
        pool.execute(target); //线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行
        pool.execute(target);//复用前面的线程
        pool.execute(target);//复用前面的线程
        
        pool.shutdown();//等待线程池的任务全部执行完毕后,关闭线程池
        pool.shutdownNow();//立即关闭线程池,不管任务是否执行完毕

    }
}

package d6_threadPoolExecutor;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //描述人物任务
        System.out.println(Thread.currentThread().getName()+"输出666--");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}
线程池处理Callable任务
package d6_threadPoolExecutor;

import java.util.concurrent.Callable;

//1.让这个类实现Callable接口
public class MyCallable implements Callable {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    //2.重写call方法
    //求1-n的和

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

package d6_threadPoolExecutor;

import d1_create_thread.MyCallable;

import java.util.concurrent.*;

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future f2 = pool.submit(new MyCallable(200));
        Future f3 = pool.submit(new MyCallable(300));
        Future f4 = pool.submit(new MyCallable(400));
        Future f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());


    }
}
线程的生命周期

乐观锁
package d7_tx;

import java.util.concurrent.atomic.AtomicInteger;

public class MyRunnable2 implements Runnable{

    //整数修改的乐观锁:原子类实现的
    private AtomicInteger number = new AtomicInteger();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

                System.out.println(number.incrementAndGet());

        }
    }
}

package d7_tx;

public class Test2 {
    public static void main(String[] args) {
        //悲观锁,乐观锁原理
        //悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差
        //乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好

        //需求:一个静态变量,100个线程,每个线程对其加100次
        Runnable target = new MyRunnable2();
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
    }
悲观锁
package d7_tx;

public class MyRunnable implements Runnable{
    private int number ;//记录浏览人次
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //悲观锁
            synchronized(this) {
                System.out.println(++number);
            }
        }
    }
}

package d7_tx;

import d7_tx.MyRunnable;

public class Test {
    public static void main(String[] args) {
        //悲观锁,乐观锁原理
        //悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差
        //乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好

        //需求:一个静态变量,100个线程,每个线程对其加100次
        Runnable target = new MyRunnable();
        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
}
陈陈陈cccc
关注
  • 22
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6003
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java多线程读取文件
Mr-Bean的博客
08-16 2410
package com.qwx.test; import java.io.*; /** * @ClassName: ReadFile * @Description: java类作用描述 * @Author: qiaowenxuan * @CreateDate: 2021/8/16$ 18:36$ * @Version: 1.0 */ public class ReadFile { public static void main(String[] args) { Fil
使用Java多线程读取txt文本文件
qq_45986997的博客
05-17 1650
1.主要知识点 2.实验代码 public class xuehao extends Thread { public void run(String a) { for(int i=0;i<30;i++) { System.out.println(a); } } } public class banji extends Thread { static String b; public void run(String a) { b = a;
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4658
Java多线程(四)线程锁
Java多线程详解
坏蛋阿土的博客
11-06 6601
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
java for循环内执行多线程
qq_38650613的博客
03-23 2万+
一、java用多线程来加快循环效率 Executors（线程池）、CountDownLatch（闭锁）
Java多线程（超详细）
qq_43390466的博客
05-23 2509
多任务处理有两种：基于进程进程是一种"自包容"的运行程序，有操作系统直接管理，直接运行，有自己的地址空间，每一个进程开启都会消耗内存基于进程的特点是允许计算机同时运行多个程序基于线程在一个程序中，能独立运行的程序片段叫做“线程”，线程是进程内部单一的顺序控制流一个进程拥有多个线程。多个线程共享一个进程的内存空间基于线程的多任务处理环境中，线程是最小的处理单位。
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5562
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
【Java多线程】停止线程
热门推荐
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
Java多线程-CountDownLatch
weixin_45203607的博客
02-16 2591
介绍 CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。 每次调用CountDown()，计数减1 主程序执行到await()函数会阻塞等待线程的执行，直到计数为0 场景 1:多线程读取批量文件, 并且读取完成之后汇总处理 2:多线程读取Excel多个sheet,读取完成之后获取汇总获取的结果 3:多个人一起一起来吃饭,主人等待客人到来,客人一个个从不同地方来到饭店,主
javaduoxiancheng.rar_多线程 java
09-24
"javaduoxiancheng.rar_多线程 java"这个压缩包文件可能包含了关于Java多线程编程的相关资料和示例代码，帮助开发者深入理解和实践Java的多线程同步机制。 首先，我们需要了解Java中线程的创建方式。Java提供了两种...
JAVA多线程JAVA多线程
02-14
Java多线程是Java编程中的一个重要概念，它允许程序同时执行多个不同的任务，极大地提高了程序的效率和响应性。在现代计算机系统中，多线程技术被广泛应用，尤其是在服务器端应用、并发处理以及高并发场景下，Java多...
多线程java买票系统
09-01
这个"多线程java买票系统"是用于教学目的，展示了如何在Java中实现多线程技术来模拟购票过程。下面将详细介绍相关知识点。 1. **线程与并发** 在计算机系统中，线程是程序执行的基本单元，每个线程都有自己的程序...
多线程Java Socket编程
12-22
采用Java 5的ExecutorService来进行线程池的方式实现多线程，模拟客户端多用户向同一服务器端发送请求. 　1.服务端 　package localSocket; 　import java.io.BufferedReader; 　import java.io.IOException; ...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 32
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 423
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 780
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 675
linux上datax 安装以及使用
多线程 Java 游戏开发
09-16
多线程Java游戏开发是一种使用多个线程同时执行不同任务的方法，以提高游戏的性能和响应速度。通过将游戏逻辑、图形渲染和用户输入处理等任务分配给不同的线程，可以实现并行处理，从而提升游戏的运行效率。 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值