线程的学习

最新推荐文章于 2024-08-04 22:17:25 发布
最新推荐文章于 2024-08-04 22:17:25 发布
阅读量24 收藏
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57408062/article/details/135017554
版权

1.概念

  • 线程(thread)是一个程序内部的一条执行路径
  • main方法的执行其实就是一个单独的执行路径
  • 程序中如果只有一条执行路径,那么这个程序就是单线程的程序

2.多线程是什么

多线程是指程序中有多条执行流程的技术

例如:消息通信,淘宝,京东系统都离不开多线程技术

1.继承Thread类

  1. 定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法.
  2. 创建MyThread类的对象.
  3. 调用线程对象的start()方法启动线程(启动后还是执行run()方法的).
  • 注意:直接调用run()方法会被当做普通方法执行,此时相当于单线程执行
  • 只有调用start方法才是启动一个新的线程执行
  • 把主线程任务放在子线程之前会出现什么问题?这样主线程一直会先跑完的,相当于是一个单线程的效果了
 public static void main(String[] args) {
        //main方法本身是一个单线程在执行的,称为主线程
        //3.创建线程对象
        Thread t=new Mythread();
        //4.调用线程对象的start方法启动线程(最终还是调用线程的run方法)
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程输出"+i);
        }
    }
}
/**1.定义线程类继承了Thread类
 * */
class Mythread extends Thread{
    //2.重写了run方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程输出"+i);
        }
    }
}

2.实现Runnable接口

  • ①定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法
  • ②创建MyRunnable任务对象
  • ③把MyRunnable任务对象交给Thread处理
  • ④调用线程对象的start()方法启动线程 
 public static void main(String[] args) {
        //3.创建一个线程任务类的对象(此对象不是线程对象)
        Runnable target=new MyRunnable();
        //4.把线程任务对象交给Thread线程对象
        Thread t=new Thread(target);
        //5.启动多线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程任务输出"+i);
        }

    }
}
/**1.定义一个线程任务类实现Runnable接口
 * */
class MyRunnable implements Runnable{
    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程任务输出"+i);
        }
    }
}

3.实现Runnable接口(使用匿名内部类) 

还可以用Lamdba表达式简化

Runnable target1=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程任务2输出" + i);
                }
            }
        };
        Thread t1=new Thread(target1);
        t1.start();

4. 实现Callable,FutureTask接口实现

  1. 得到任务对象:①定义类实现Callable接口,实现call方法,封装要做的事情②用FutureTask和Callable对象封装成线程任务对象
  2. 把线程任务对象交给Thread处理
  3. 调用Thread的start方法启动线程,执行任务
  4. 线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果
  public static void main(String[] args) {
        //3.创建一个Callable的执行对象
        Callable<String> call1=new MyCallable(100);
        //4.把Callable包装成未来任务对象
        FutureTask<String> f1=new FutureTask<>(call1);
        //5.交给Thread对象
        Thread t1=new Thread(f1);
        //6.启动线程
        t1.start();

        Callable<String> call2=new MyCallable(999);
        FutureTask<String> f2=new FutureTask<>(call2);
        Thread t2=new Thread(f2);
        t2.start();

        //7.得到线程执行完毕后的结果
        try {
            //主线程执行到这里,如果上面第一个线程没有执行完毕,这里会让出cpu,等待第一个线程执行完毕之后才能执行这个代码取结果
            String s1=f1.get();
            System.out.println(s1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String s2=f2.get();
            System.out.println(s2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**
 * 1.定义一个类实现callable接口
 */
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }
    //2.重写call方法,定义执行的任务和返回的结果
    @Override
    public String call() throws Exception {
        //需求:计算0-100的和
        int sum=0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return "子线程帮助计算0-"+n+"的和是:"+sum;
    }
}

3.Thread常用方法

4.线程安全问题

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

1)线程安全问题出现的原因?

  • 存在多线程并发
  • 同时访问共享资源
  • 存在修改共享资源 

2)线程安全问题的解决方案

  • 解决方案1:同步代码块
 synchronized (this) {
出现问题的代码
}
  • 解决方案2:同步方法:出现问题的方法用synchronized修饰
public synchronized void drawMoney(double money){
}
  • 解决方案3:lock锁
 //锁对象属于账户对象,而且唯一不可更改
    private final ReentrantLock lock=new ReentrantLock();
lock.lock();//上锁
try{
}
 finally {
            lock.unlock();//解锁

        }

5.线程通信

1)概念:线程间相互发送数据.

2)常见形式

  • 通过共享一个数据的方式实现
  • 根据共享数据的情况决定自己该怎么做,以及通知其他线程怎么做

3)线程通信的三个方法

  • wait()
  • notify()
  • notifyAll()

 注意:上述方法应该使用当前同步锁对象进行调用

6.线程池(重点)

概念:可以复用的技术;

代表:JDK5.0起提供了代表线程的接口:ExecutorService

如何得到线程池对象?

  • 方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
  • 方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象

1)面试高频题目:

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

什么时候会开始拒绝任务?核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝.

2)Executor方法

3)新任务的拒绝策略 

4)线程池操作Runnable任务 

  public static void main(String[] args) {
        /**  public ThreadPoolExecutor(int corePoolSize,
         int maximumPoolSize,
         long keepAliveTime,
         TimeUnit unit,
         BlockingQueue<Runnable> workQueue,
         ThreadFactory threadFactory,
         RejectedExecutionHandler handler) {
         * */
        Executor pool=new ThreadPoolExecutor(3,5,10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        //提交任务给线程处理
        Runnable my=new MyRun();
        pool.execute(my);
        pool.execute(my);
        pool.execute(my);
        pool.execute(my);
        pool.execute(my);
        pool.execute(my);//排满了,临时线程的时机
        pool.execute(my);
        pool.execute(my); //出现任务拒绝的时机
        pool.execute(my);
    }
}
/**1.定义一个线程任务类实现Runnable接口
 * */
class MyRun implements Runnable{
    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"输出"+i);
        }
        try {
            Thread.sleep(100000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 5)线程池操作callable任务

public class d6_线程池实现callable {
    public static void main(String[] args) {
        ExecutorService pool1=new ThreadPoolExecutor(3,5
                ,10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        Future<String> s1 = pool1.submit(new MyCall(100));
        try {
            System.out.println(s1.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        Future<String> s2 = pool1.submit(new MyCall(200));
        try {
            System.out.println(s2.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        Future<String> s3 = pool1.submit(new MyCall(300));
        try {
            System.out.println(s3.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        Future<String> s4 = pool1.submit(new MyCall(400));
        try {
            System.out.println(s4.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**
 * 1.定义一个类实现callable接口
 */
class MyCall implements Callable<String> {
    private int n;
    public MyCall(int n){
        this.n=n;
    }
    //2.重写call方法,定义执行的任务和返回的结果
    @Override
    public String call() throws Exception {
        //需求:计算0-100的和
        int sum=0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return  Thread.currentThread().getName()+"计算1-"+n+"的和是:"+sum;
    }
}

6)Executors使用可能存在的陷阱

public class d7_线程池 {
   public static void main(String[] args) {
      ExecutorService pool=Executors.newFixedThreadPool(3);
      pool.submit(new MyRun1());
      pool.submit(new MyRun1());
      pool.submit(new MyRun1());
      pool.submit(new MyRun1());
      pool.submit(new MyRun1());
      pool.submit(new MyRun1());
   }
}
/**1.定义一个线程任务类实现Runnable接口
 * */
class MyRun1 implements Runnable{
   //2.重写run()方法
   @Override
   public void run() {
      for (int i = 0; i < 10; i++) {
         System.out.println(Thread.currentThread().getName()+"输出"+i);
      }
      try {
         Thread.sleep(100000);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

 7.定时器

  • 推荐使用ScheduleExecutorService
  • 基于线程池 某个任务执行出现问题的情况不会影响其他定时任务的执行
  ScheduledThreadPoolExecutor pool=new ScheduledThreadPoolExecutor(3);
        pool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"----aaaa");
            }
        },0,2, TimeUnit.SECONDS);
        pool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"----bbbbb");
            }
        },0,1, TimeUnit.SECONDS);

 8.并发和并行

概念:正在运行的程序(软件)被称为进程,线程是输入进程的,多线程其实是并发与并行同时存在的

并发理解:

  • CPU同时执行线程的数量:与CPU的核数和逻辑处理器有关系;
  • CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,给我们感觉这些线程在同时执行,这就是并发

并行的理解:同一时刻同时在执行

9.线程的6种状态

m0_57408062
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
线程学习笔记
weixin_44192849的博客
01-03 2380
1.线程 概念：多条流程执行的技术叫做多线程，例如一个购票系统可以有多个人同时购票。 1.1 多线程的实现方式一：继承Thread类 示例：
labview多线程学习
09-03
多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**：线程是程序中的执行单元，一个进程可以包含一个或多个线程。在LabVIEW中，多线程允许同时执行多个任务，实现程序的并行处理，提高系统的响应速度和整体...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
多线程学习思维导图
weixin_44448094的博客
03-09 1565
java多线程学习（超详细吐血总结）
chenruijia170707的博客
11-11 2万+
声明：原文出处http://www.cnblogs.com/nsw2018/p/5822270.html，本人出于学习，收集干货，不作商业用途！以下原作者为林炳文Evankaka的原创作品。转载出处：http://blog.csdn.net/evankakahttp://blog.csdn.net/evankaka/article/details/44153709#t1  （java线程学习的入门...
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
Python 多线程学习
Herishwater的博客
05-10 3501
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
C++多线程学习
weixin_43186817的博客
09-25 1738
先是一名搬运工，搬运C++多线程学习的文章，再好好学习，天天向上。 先是一个大佬博主的文章：关于C++进阶的，写得很是详细，膜拜啊！ C++进阶主题 其次，是该博主多线程的具体文章 C++多线程（一）thread类 c++ 多线线程（二）-mutex c++ 11 多线线程 future 接着是另一个博主写的多线程的文章，比较通俗易懂，大家懂得~ C++多线程类Thread（C++11 ...
多线程学习完整流程图
大西瓜超帅
06-02 1289
多线程学习最完整流程图
线程学习（17）park,unpark
key_wu的博客
05-30 3103
个人笔记，勿喷
线程学习
02-17
线程学习是编程领域中的一个重要概念，特别是在Java这种多线程支持的语言中。Java线程允许程序同时执行多个任务，从而提高系统效率和资源利用率。本文将深入探讨Java线程的相关知识点，帮助你掌握线程的基本操作、...
线程学习.docx
03-08
### 线程学习知识点详解 #### 一、线程基础概念 在计算机科学中，线程（Thread）是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。简单来说，一个进程可以拥有多个线程，而每...
Java基础巩固之线程学习
01-20
一、线程的学习 　线程是程序中执行单个任务的顺序的流程。 　线程创建的两种方式： 　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { ...
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
从根儿上学习spring 九 之run方法启动第四段(3)
baidu_19338587的博客
08-04 524
一般情况下调用doGetBean方法获取的bean实例都是为了真实使用的，像我们上面举得A，B对象的例子获取的A，B对象当然都是为了真实使用的，但有种场景就只是为了做类型检查，比如有时候为了判断FactoryBean里的对象的类型就要先获取FactoryBean再通过getObject方法获取里面的真实对象来判断其类型，这时获取的FactoryBean实例可能就只是为了类型检查并不是为了真实使用。二:当bean是多例时，会有不同的创建bean的逻辑，下面我们按照代码顺序先分析单例的情况。
PySide6/PyQT学习笔记（很杂）
m0_56230886的博客
08-04 177
持续更新……
Linux shell编程学习笔记68： curl 命令行网络数据传输工具 选项数量雷人（上）
最新发布
Purpleendurer@CSDN
08-04 695
在网络时代，有经常需要在网络上传输数据，时我们需要通过网络下载文件，为了满足这种时代需要，Linux提供了众多网络命令，我们今天先研究curl命令。例如，我们可以使用curl从 URL 下载文件，或将文件上传到服务器。
从根儿上学习spring 五 之run方法启动第二段
baidu_19338587的博客
08-04 433
讲完了PropertySources和PropertySource，我们再回头看图6的方法configurePropertySources方法似乎变得很简单没必要一行行分析了吧，这个方法就是向environment的sources属性里加入启动时的两个PropertySource，有不清楚的同学再结合我上面说的对着代码看两遍就清楚了，我就不再赘述了。Environment接口继承了PropertyResolver接口，PropertyResolver接口主要提供了获取配置属性的方法，如图3所示。
java多线程学习计划
12-21
以下是一个Java多线程学习计划的简要介绍： 1. 学习多线程的基本概念：了解程序、进程和线程的概念，以及多线程的优点和何时需要使用多线程。 2. 学习线程的创建和使用：掌握使用Thread类创建和启动线程的方法，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值