多线程内容

最新推荐文章于 2024-05-07 11:39:23 发布
最新推荐文章于 2024-05-07 11:39:23 发布
阅读量84 收藏
点赞数
分类专栏： # JavaSE 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53063293/article/details/128461092
版权

线程（thread）：

        一个程序内部的一条执行路径。main方法的执行就是一条单独的执行路径。

多线程：

        是指从软硬件上实现多条执行流程的技术。

 1.多线程的创建：

        方法一：继承Thread类

实现步骤：

  • 先写一个Thread的子类，重写run方法。
  • public class MyThread extends Thread{
    @Override
    public void run() {
        //run方法中写线程要执行的事情。
        for (int i = 1; i <= 100; i++) {
            System.out.println(getName()+"已经下载了..."+i+"%");
        }
    }
}
  • 创建Thread的子类对象。
  • 调用start方法启动线程（自动执行run方法，不可以直接调用run方法。只能调用start方法开启线程。）
  • /**
 * 线程的第一种创建方式步骤：
 *      1.先写一个Thread的子类，重写run方法。
 *      2.创建Thread的子类对象。
 *      3，调用start方法启动线程（自动执行run方法）
 *      (不可以直接调用run方法，只能调用start方法开启线程)
 */
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        MyThread t1=new MyThread();
        //设置线程名称
        t1.setName("海贼王");
        //启动线程
        t1.start();

        MyThread t2=new MyThread();
        t2.setName("火影忍者");
        t2.start();

        //这里的for循环被主线程执行：主线程的名称是main。
        for (int i = 0; i < 100; i++) {
            //线程睡眠
            Thread.sleep(1000);
            Thread thread=Thread.currentThread();
            System.out.println(thread.getName()+"已经下载了..."+i+"%");
        }
    }
}

        方法二：实现Runnable接口

实现步骤：

  • 定义一个Runable接口的实现类，作为线程的任务类，需要重写run方法。
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            //获取当前线程的对象：哪一个线程执行run方法，这里获取的就是哪一个线程对象
            Thread thread=Thread.currentThread();
            //获取线程名
            String name=thread.getName();
            System.out.println(name+"正在下载..."+i+"%");
        }
    }
}
  • 创建线程任务的对象。
  • 把线程任务的对象，交给Thread类的对象。
  • 让Thread的对象调用start方法，启动线程。（会自动执行任务类中的run方法）
/**
 * 线程第二种创建方式的步骤：
 *      1.写一个Runnable接口的实现类，作为线程的任务类，需要重写run方法
 *      2.创建线程任务的对象
 *      3.把线程任务的对象，交给Thread类的对象
 *      4.让Thread的对象调用start方法，启动线程（会自动执行任务类中的run方法）
 *
 * 优点：
 */
public class Demo {
    public static void main(String[] args) {
        //创建线程任务类的对象
        MyRunnable mr=new MyRunnable();

        //创建线程对象，把任务交给线程
        Thread t1=new Thread(mr);

        //启动线程
        t1.start();

        /**
         *实现Runnable接口（匿名内部类形式）
         */
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    //获取当前线程的对象：哪一个线程执行run方法，这里获取的就是哪一个线程对象
                    Thread thread = Thread.currentThread();
                    //获取线程名
                    String name = thread.getName();
                    System.out.println(name + "正在下载..." + i + "%");
                }
            }
        });
        t2.start();
    }
}

优点：线程任务类只是实现了Runnable接口可以继续继承和实现。

        方法三：实现Callable接口

优点：可以得到线程执行的返回值。

        实现步骤

  • 写一个Callable接口的实现类，重写call方法
/**
 * Callable接口的实现类:用来封装线程要执行的事情，重写call方法，方法执行完毕之后有返回值
 *      想要返回什么类型的数据，泛型就写什么类型
 */
public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 10;
    }
}
  • 创建Callable接口的实现类对象
  • 创建一个FutureTask类的对象，把Callable实现类对象封装进来
  • 创建Thread对象，把FutureTask对象封装进来。
  • 调用Thread对象的start方法。
/**
 * 线程的第三种创建方式的步骤：
 *      1.写一个Callable接口的实现类，重写call方法
 *      2.创建Callable接口的实现类的对象
 *      3.创建一个FutureTask类的对象，把Callable实现类对象封装进来
 *      4.创建Thread对象，把FutureTask对象封装进来
 *      5.调用Thread对象的start方法。
 */
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口的实现类的对象
        MyCallable mc=new MyCallable();

        //创建一个FutureTask类的对象，把Callable实现类对象封装进来
        FutureTask<Integer> ft=new FutureTask<>(mc);

        //创建Thread对象，把FutureTask对象封装进来
        Thread t1=new Thread(ft);

        //调用Thread对象的start方法。
        t1.start();

        //等线程的任务代码执行完毕了（call方法执行完了）,就要返回结果，结果会封装到FutureTask对象里面
        //通过FutureTask对象获取返回值。
        Integer result=ft.get();
        System.out.println("线程执行的结果是："+result);
    }
}

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

        可以在线程执行完毕后去获取线程执行的结果。

缺点： 编码复杂一点

 

 

 2.Thread的常用方法：

getName():获取当前线程的名称。

setName():设置当前线程的名称。

Thread currentThread():返回当前正在执行的线程对象的引用。

        1.此方法是Thread类的静态方法，可以直接调用Thread类调用。

        2.这个方法在哪个线程执行中调用，就会得到哪个线程对象。

sleep(long time): 指定休眠时间。单位为毫秒。

 3.线程安全：

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

/**
 * 账户类：用于封装账户的金额信息
 */
public class Account {
    private int money=10000;//余额

    //取钱的方法：其实就是对账户的余额进行更新操作。
    public void drawMoney(int money){
        String name = Thread.currentThread().getName();
        //判断余额是否足够
        if (this.money>=money){
            try {
                Thread.sleep(1000);//线程1，线程2
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.money-=money;
            System.out.println(name+"过来取钱了，取了"+money+"元,还剩下"+this.money+"元");
        }else {
            System.out.println(name+"过来取钱了，可是没钱了");
        }
    }
}
public class DrawThread extends Thread{
    private Account account;

    public DrawThread(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.drawMoney(10000);
    }
}
/**
 * 线程安全问题发生的原因：多个线程同时访问同一个共享资源且存在修改该资源。
 */
public class Demo {
    public static void main(String[] args) {
        Account account=new Account();
        DrawThread dt1=new DrawThread(account);
        DrawThread dt2=new DrawThread(account);

        dt1.start();
        dt2.start();
    }
}

 

 4.线程同步：

核心思想：加锁（把访问共享资源的代码封住，只有获取锁的线程可以执行，没有获得锁就不能执行。）

        1.同步代码块：

作用：把出现线程安全问题的核心代码给上锁。

 

        锁对象规范要求：

  •         规范上：建议使用共享资源作为锁对象。
  •         对于实例方法建议使用this作为锁对象。
  •         对于静态方法建议谁用字节码（类名.class）对象作为锁对象。
  • /**
 * 同步代码块
 */
        synchronized (Aaccount.class){
            //判断余额是否足够
            if(Aaccount.money>=money){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //可以取钱
                Aaccount.money-=money;
                System.out.println(name+"过来取钱，取了"+money+"元，还剩"+Aaccount.money);
            }else {
                System.out.println(name+"过来取钱，余额不足");
            }
        }

        2.同步方法：

 

/**
     * 同步方法
     * 如果是实例方法：锁对象是this
     * 如果是静态方法：锁对象是类名.class
     */
    public synchronized void drawMoeny(int money){
        //获取线程名称，方便后面使用
        String name = Thread.currentThread().getName();

        //判断余额是否足够
        if(Aaccount.money>=money){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //可以取钱
            Aaccount.money-=money;
            System.out.println(name+"过来取钱，取了"+money+"元，还剩"+Aaccount.money);
        }else {
            System.out.println(name+"过来取钱，余额不足");
        }
    }

        3.Lock锁：

为了更清晰的表达如何加锁和释放锁，Lock更加灵活，方便。Lock是接口，一般采用实现类ReentrantLock来表示锁对象。

public  void drawMoeny(int money){
        //获取线程名称，方便后面使用
        String name = Thread.currentThread().getName();

        lock.lock();//上锁
        //判断余额是否足够
        try {
            if(this.money>=money){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //可以取钱
                this.money-=money;
                System.out.println(name+"过来取钱，取了"+money+"元，还剩"+this.money);
            }else {
                System.out.println(name+"过来取钱，余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }

 5.线程通信：

所谓线程通信就是线程之间相互发送指令，从而改变线程执行状态。

        如何实现：

  • 多个线程之间需要有共性数据
  • 线程根据共享数据的情况决定自己该怎么做，是让线程等待，还是让线程唤醒。

        实际应用场景：

  • 生产者和消费者模型：生产者负责生产数据，消费者负责消费生产者产生的数据。
  • 要求：生产者线程生产完毕数据后唤醒消费者，然后等待自己，消费者消费玩该数据后唤醒生产者，然后等待自己。

        线程通信的前提：

                线程通信通常是在多个线程操作同一个共享资源的时候进行通信，且保证线程安全。

/*
账户类： 封装账户的余额信息，还有存钱和取钱的方法
 */
public class Acount {
    //账户的余额， 默认是10万元
    private int money = 100000;

    /**
     * 取钱的方法
     * @param money 要取钱的金额
     */
    //同步方法的锁对象：this
    public synchronized void drawMoney(int money){
        String name=Thread.currentThread().getName();
        //1.判断余额是否足够
        if (this.money>=money){
            //2.如果余额足够，开始取钱，取完钱后，唤醒其他等待的线程
            this.money-=money;
            System.out.println(name+"过来取了"+money+"元，还剩"+this.money+"元");
            this.notifyAll();
        }else {
            //3.如果余额不足，不能取钱，让当前线程等待
            try {
                this.wait();//释放锁等待。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }

    /**
     * 存钱的方法
     * @param money 要存钱的金额
     */
    //同步方法的锁对象时: this
    public synchronized void saveMoney(int money){
        String name=Thread.currentThread().getName();
        //1.判断余额是否足够
        if (this.money==0){
            //2.如果余额不足，开始存钱，存完钱后，唤醒其他等待的线程
            this.money+=money;
            System.out.println(name+"过来存了"+money+"元，还有"+this.money+"元");
            this.notifyAll();
        }else {
            //3.如果余额足够，不能存钱，让当前线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class DrawThread extends Thread{
    private Acount acount;

    public DrawThread(Acount acount){
        this.acount=acount;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            acount.drawMoney(100000);
        }
    }
}
public class SaveThread extends Thread{
    private Acount acount;

    public SaveThread(Acount acount){
        this.acount=acount;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            acount.saveMoney(100000);
        }

    }
}
public class Demo {
    public static void main(String[] args) {
        //创建三个存钱线程、两个取钱线程、这五个线程共享同一个账户。
        Acount acount=new Acount();
        SaveThread t1=new SaveThread(acount);
        t1.setName("爸爸");
        SaveThread t2=new SaveThread(acount);
        t2.setName("妈妈");
        SaveThread t3=new SaveThread(acount);
        t3.setName("哥哥");

        DrawThread t4=new DrawThread(acount);
        t4.setName("小弟");
        DrawThread t5=new DrawThread(acount);
        t5.setName("小妹");
        
            t1.start();
            t2.start();
            t3.start();
            t4.start();
            t5.start();

    }
}

wait():当前线程等待，直到另一个线程调用notify()或notifyAll()唤醒自己

notify():唤醒正在等待对象监视器（锁对象）的单个线程

notifyAll():唤醒正在等待对象监视器（锁对象）的所有线程

6.线程池：

线程池就是一个可以复用线程的技术。

（如果用户每发起一个请求，后台就创建一个新的线程来处理，下次新任务又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。）

实现线程池：（JDk5起提供了代表线程池的接口：ExecutorService）

 

 

public class Demo1 {
    public static void main(String[] args) {
        //创建线程池对象
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                3,                          //核心线程数
                5,                      //最大线程数
                2,                         //临时线程存活时间
                TimeUnit.SECONDS,                       //指定存活时间的单位
                new ArrayBlockingQueue<>(10),   //指定任务队列
                Executors.defaultThreadFactory(),       //指定用哪个线程工厂创建队列
                new ThreadPoolExecutor.AbortPolicy()    //指定拒绝线程策略
        );
        //

        for (int i = 1; i <= 17; i++) {
            int j=i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"线程执行了.."+j+"号任务");
                }
            });
        }

        //关闭线程池
        pool.shutdown();

    }
}

 

public class Demo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                3,
                5,
                4,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        Future<Object> submit = pool.submit(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }
        });

        System.out.println(submit.get());
        pool.shutdownNow();
    }
}

 

 

线程池常见面试题：

临时线程什么时候创键?

        核心线程都在忙+任务队列满了，就会创建临时线程。

什么时候会开始拒绝任务？

        核心线程都在忙+临时线程也在忙+任务队列也满了，多余的任务就会触发拒绝策略

        

7.并发，并行

正在运行的程序（软件）就是一个独立的进程，线程是 属于进程的，多个线程其实是并发与并行同时进行的。

并发：

        CPU同时处理的线程数量有限。

        CPU会轮询为系统的每个线程服务，由于CPU切换速度很快，给我们的感觉这些线程在同时执行，这就是并发。

 

并行：

        在同一时刻上，同时有多个线程在被CPU处理并执行。

 

8.线程的生命周期：

线程的生命周期指的是，线程从创建到销毁的过程可能存在不同的状态。

线程的状态

        线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。

        Java总共定义了6种状态

        6种状态都定义在Thread类的内部枚举类中。

 

 

 

程序员要奋斗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
QT多线程技术读取文档内容到程序里
07-26
为了防止直接读取文件里的内容太大而发生卡顿，于是多线程读取将更高效的解决这个问题。 效果图如下： 其中pro文件无需改动，默认就好，头文件h里面的内容为 #ifndef MAINWINDOW_H #define MAINWINDOW_H #...
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Java多线程详解
坏蛋阿土的博客
11-06 6538
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
SpringBoot--多线程处理
IT利刃出鞘的博客
07-31 1万+
本文介绍SpringBoot多线程处理的方案。
多线程 join 方法
Gonelin的博客
12-22 6067
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
C# 异步 多线程
wokao253615105的专栏
02-24 4502
转载自https://www.cnblogs.com/doforfuture/p/6293926.html C#中 Thread，Task，Async/Await，IAsyncResult 的那些事儿！ 说起异步，Thread，Task，async/await，IAsyncResult 这些东西肯定是绕不开的，今天就来依次聊聊他们 ...
Python多线程详解
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
多线程多线程.xmind
11-07
该文档是笔者在学习李刚老师《Java疯狂讲义》中有关多线程的用法而总结出来的笔记，其中主要的内容包括线程创建和启动、线程的生命周期、控制线程、线程同步、线程通信线程池等基本内容。对Java多线程有详细的介绍。
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程读取大文件
12-22
为了提高速度，自然还得用上多线程技术。 　接下来介绍一下实现思路以及相关的知识点。 　内容 　一、对文件分区 　为了充分利用多线程读取，需要把文件划分成多个区域，供每个线程读取。那么需要有一个算法来...
多线程多线程.zip
11-07
该文档是笔者在学习李刚老师《Java疯狂讲义》中有关多线程的用法而总结出来的笔记，其中主要的内容包括线程创建和启动、线程的生命周期、控制线程、线程同步、线程通信线程池等基本内容。对Java多线程有详细的介绍。...
Linux下网络编程-简易Epll服务器和客户端
weixin_45256307的博客
05-06 397
Linux下网络编程-简易Epll服务器和客户端
java: 通过证书访问etcd
最新发布
amadeus_liu2的博客
05-07 197
可通过etcdctl 进行连接验证。四、创建客户端，访问etcd。二、带证书启动etcd。
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 1023
一篇文章，系统性聊聊Java注解
Java代码基础算法练习-删除有序数组中的重复项-2024.05.07
Sakurapaid的博客
05-07 182
给一个有序数组（共10个元素），请在不新建数组的情况下，删除重复出现的元素，使 每个元素只出现一次，最后请输出删除重复元素后数组的新长度和数组元素。要删除有序数组中的重复项，且不使用额外数组，可以采用。
vb.net多线程内容的书籍
10-10
有很多关于VB.NET多线程内容的书籍可供选择。以下是其中一些比较受欢迎的书籍推荐： 1.《Visual Basic中的多线程编程》：这本书是Arndt Ebert和Ulrich Klose合著的一本指导性书籍。它提供了VB.NET多线程编程的详细...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值