多线程总结

最新推荐文章于 2022-05-09 22:25:48 发布
最新推荐文章于 2022-05-09 22:25:48 发布
阅读量87 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blank_zio/article/details/117918000
版权

多线程

基础概念
  1. 程序（program）：一段静态代码，一组指令的集合
  2. 进程（process）：程序的一次执行过程，或是一个正在运行的程序，资源分配的单位
  3. 线程（thread）:一个进程可以有多个线程，是独立调度和分派的基本单位
  4. 线程共享方法区和堆，stack和program couter Register（程序计数器）单独
  5. 并行：多个cpu同时执行多个任务
  6. 并发：一个cpu采用时间片轮转法执行多个任务
  7. 多线程优点：提高程序响应性，提高cpu利用率，改善程序结构（单核cpu多线程执行有可能速度反而变慢）
什么时候需要多线程

  1. 需要同时执行两个货多个任务

  2. 程序需要实现一些要等待的任务

  3. 需要一些后台运行程序

实现多线程方式
继承Thread类
  1. 不可以直接在主线程调用run方法，这样并没有启动新的线程
  2. 同一个子类线程对象只能执行一次start()方法，否则会抛出异常,
  3. 要多个线程只能创建多个对象
if (threadStatus != 0)
    throw new IllegalThreadStateException();

/**
 * @description:
 * @author: liSen
 * @time: 2021/6/4 19:40
 */
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建子类对象执行Start方法
        new MyThread().start();//start()方法执行步骤1.启动当前的线程2.执行run方法
        for (int i = 0; i <100; i++) {
            System.out.println(Thread.currentThread().getName());
            System.out.println("主线程");
        }
        
        //匿名子类
        new Thread() {
            @Override
            public void run() {
                System.out.println("这是子线程");
            }
        }.start();

    }
}

//1.创建继承Thread子类
class MyThread extends Thread{
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());
            System.out.println("子线程执行");
        }
    }
}
实现Runnable接口
package com.company.Thread;

/**
 * @description:
 * @author: liSen
 * @time: 2021/6/4 22:07
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        //3.创建实现类对象
        MThread mThread = new MThread();
        //4.创建Thread对象
        Thread thread = new Thread(mThread);
        //5.调用start方法
        thread.start();
    }
}

//1.创建一个时间Runnable接口的类
class MThread implements Runnable{

    //2.生成run方法
    @Override
    public void run() {
        System.out.println("子线程1 ");
    }
}

比较实现Runnable更好

  1. 没有单继承限制
  2. 能解决多线程数据共享问题
实现Callable接口
/**
 * @description: 使用Callable实现多线程，jdk5.0
 * @author: liSen
 * @time: 2021/6/9 16:13
 */
public class ThreadNew {
    public static void main(String[] args) {
        //3.生成sum实例
        Sum sum = new Sum();
        //4.生成FutureTask实例
        FutureTask<Integer> futureTask = new FutureTask(sum);
        //5.new 一个新的线程
        new Thread(futureTask).start();
        Integer o = null;

        //6.可以获取call的返回值
        try {
            o = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(o);
    }
}
//1。实现Callable接口(可以使用泛型)
class Sum implements Callable<Integer>{
    private Integer sum = 0;

    //2.实现call方法（可以有返回值）
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
               sum +=i;
                System.out.println(i);
            }
        }
        return sum;
    }
}

比Runnable好

  1. 可以使用泛型
  2. call可以有返回值
  3. 可以抛出异常被捕获
线程池
方法

  1. String getName()获取某个线程的名字

    Thread.currentThread().getName()//获取当前线程的名字
Thread thread1 = new MyThread()
thrad1.getName();//获取thread1线程的名称

  2. void start() 启动线程，并执行线程的run方法

    new Mythread().start();

  3. run()线程在被调度时的执行操作

  4. void setName() 设置该线程的名称

    1.给主线成命名
Thread.currentThread().setName("123");
2.线程子类实现构造器，
    //Thread类自带的命名构造器
     public Thread(String name) {
        init(null, null, name, 0);
    }
	//在自己子类实现就好
    public MyThread(String threadName){
        super(threadName);
    }

  5. static Thread currentThread() 返回当先线程，在子类中就是this,通常在主线下和Runnable实现

  6. yield()释放当前cpu的执行权，重新分配执行线程，可能被一个线程连续多次抢到执行权

    //1.创建继承Thread子类
class MyThread extends Thread{
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            System.out.println(Thread.currentThread().getName());
            System.out.println("子线程执行");
            if(i % 5 == 0){
                yield();
            }
        }
    }
/*    public MyThread(String threadName){
        super(threadName);
    }*/
}

  7. join()在线程A调用线程B的join(),线程A进入阻塞状态，直到线程B执行完后，线程A才结束阻塞

  8. stop()已过时，强制结束线程生命

  9. sleep(long millitme)让当前线程数目指定毫秒，指定时间内线程时阻塞的

  10. isAlive()判断线程是否存在

  11. setPriority/getPriority()设置/获取线程的优先级，高优先级抢占只是概率问题(线程的优先权高度依赖于系统，例如win有七个优先权，java的优先级映射到操作系统的优先级中，但是在Oracle未linux提供的ava虚拟机会忽略线程优先级—所有线程优先级相同。现在不推荐使用优先级)

  12. Thread.State getState()获取当前线程的状态，NEW、RUNNABLE…

线程调度策略
  1. 调度策略：时间片，特点：抢占式（高优先级的线程抢占cpu）
  2. Java调度方式：
    1. 同级线程组成先进先出的队列（先到先服务），使用时间片策略
    2. 对高优先级，室友优先级的抢占策略
  3. 线程的优先级：
    1. MAX_PRIORITY =10
    2. MIN_PRIORITY = 1
    3. NORM_PRIORITY = 5
    4. 设置优先级：
      1. setPriority()
      2. getPriority()
线程安全问题
  1. 多个线程方位同一个变量如买票时票的总数，如果使用extends Thread实现多线程，应将该变量设置为static，多个线程访问同一份变量，Runnble是实现是因为只有子类一份实现类，所以无需使用。
线程的生命周期
public enum State {
    NEW,//新建：new Thewad(r),线程刚创建还未启动

    RUNNABLE,//可运行的，调用start()方法就是处于可运行状态,因为操作系统采用的是抢占式的调度，时间片用完剥夺运行权给其他线程，所以是线程是在运行，也可能没在运行

    BLOCKED,//阻塞:当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状态；当该线程持有锁时,该线程将变成Runnable状态

    WAITING,//等待:一个线程在等待另一个线程执行一个(唤醒)动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒

    TIMED_WAITING,//计时等待:同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态,这一状态将一直保持到超时期满或者接收到唤醒通知,带有超时参数的常用方法有Thread.sleep、锁对象.wait()

    TERMINATED;//终止:因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡
}
  1. 新建（new）：线程被创建时
  2. 就绪：新建线程被start()后，线程进入线程队列等待cpu时间片，此时已经具备运行条件，只是没有分配资源
  3. 运行：就绪线程被调度获得cpu资源，进入运行状态，run()定义了线程的操作和功能
  4. 阻塞：在某种特殊情况下，被人为挂起或者执行输入输出操作时，让出cpu并临时终止自己的执行，进入阻塞
  5. 死亡：线程完成了他的全部工作或者线程被提前强制性终止或异常导致结束

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0uh2WU03-1623719406840)(D:\Document\note\java重新开始\基础\pic\thread.jpg)]

线程同步
同步代码块
//1.创建一个时间Runnable接口的类
class MThread implements Runnable{
    private Integer t =100;
   Object obj = new Object();//多个线程必须用同意把锁


    //2.生成run方法
    @Override
    public void run() {
       whlie(true){
            synchronized(obj){//同步监视器：锁，任何一个对象，类都可以当锁
            //synchronized(this){//同步监视器：锁，任何一个对象，类都可以当锁
            synchronized(MThread.class){//类只会加载一此所以可以当锁
                //被同步的代码（操作共享数据的代码）
                //共享数据：多个线程操作的数据
                t--;
                System.out.println(t);
            }
        }
        System.out.println("子线程1 ");
    }
}

//1.创建继承Thread子类
class MyThread extends Thread{

    private static Integer t =100;
    //2.重写run方法
    @Override
    public void run() {
        while (true){
            synchronized(MyThread.class){//保证锁的唯一性（继承不能用this,new 对象，因为会有多个实例）
                    t--;
            }

            System.out.println(Thread.currentThread().getName());
            System.out.println("子线程执行");

        }
    }

}

被同步的代码块相当于单线程

同步方法
//1.创建继承Thread子类
class MyThread extends Thread{

    private static Integer t =100;//static多个对象访问同一个元素

    @Override
    public void run() {
       while(true){
           show();
       }
    }


    public static synchronized void show(){//加上static 同步锁是类本身即MyThread.class 反之为this即生成对象（失败）

        if(t > 0){
            t--;
            System.out.println(t);
        }
    }
}

//1.创建一个时间Runnable接口的类
class MThread implements Runnable{
 private Integer t =100;
    @Override
    public void run() {
       while(true){
           show();
       }
    }

    public  synchronized void show(){//默认是this,继承Runnable只有一个实例对象（可以）

        if(t > 0){
            t--;
            System.out.println(t);
        }
    }
}
Lock（锁）
class Window implements Runnable{

    private Integer t = 100;
   private ReentrantLock rt =  new ReentrantLock(true);//使用可重用锁 （fair:ture,线程按照先进先出的结构使用资源，而非抢占，默认fair:false）

    @Override
    public void run() {
        while (true){
            try{
                rt.lock();//添加锁
                if(t>0){
                    t--;
                    System.out.println(Thread.currentThread().getName()+"----------"+t);
                }
            }finally {
                rt.unlock();//解除锁
            }
        }
    }
}
synchronized与Lock
  1. 推荐使用顺序：Lock—同步代码块—同步方法
  2. 不同：Lock需要手动添加同步锁（lock）,手动释放同步锁（unlock）
同步锁解决懒汉式线程安全问题
//同步方法
class Person{

    private static Person p1 = null;

    private Person(){//私有不让在外部new对象
        System.out.println("对象");
    }

    public static synchronized Person getPerson(){//同步方法，默认指向this
        if(p1 == null){
            p1 = new Person();
        }
        return p1;
    }
}

//同步代码块
class Person{

    private static Person p1 = null;

    private Person(){
        System.out.println("对象");
    }

    public static  Person getPerson(){
        if(p1 == null){//防止已经生曾对象，多个对象还在等待进去
            synchronized(Person.class){
                if(p1 == null){//有多个对象在排队到同步区域，判断是否已经存在
                    p1 = new Person();
                }
            }
        }
        return p1;
    }
}
死锁
  1. 不同的线程分别占用对方需要同步的资源不放弃，都在等对方放弃自己同步的资源，造成死锁
线程通信
class Number implements Runnable{

   private Integer t = 100;
   Object obj = new Object();
    @Override
    public void run() {
        while (true){
//            synchronized(this){
            synchronized(obj){
                //notify(); //默认是this,当锁不是this时候因为两个不同会报异常 （java.lang.IllegalMonitorStateException）
                obj.notify(); //方法继承于object,指向和锁相同即可
                if(t>0){
                    System.out.println(Thread.currentThread().getName()+"-------------"+t);
                    t--;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }

            }
        }

    }
}
方法
  • **wait()😗*等待，一但执行此方法线程进入组赛状态，释放同步监视器
  • **notify()😗*执行此方法，有一个线程被唤醒，有多个线程的时候根据优先级唤醒一个
  • notifyAll():执行此方法，唤醒所有等待的线程
说明
  1. 三个方法必须在同步代码块中使用
  2. 三个方法必须与同步锁指向同一个对象，否则出现异常
  3. 三个方法继承自Object对象
wait()和sleep()异同

相同：

  1. 两者都可以使得线程进入阻塞状态

不同：

  1. sleep()属于Thread()方法，wait()属于Object()
  2. sleep()不依赖与同步代码监视器synchronized,wait()依赖与synchronized
  3. sleep()不会释放lock,wait()会释放lock
  4. sleep()不用手动唤醒(到时间自动唤醒)，wait()需要手动唤醒
生产者消费者问题
package com.company.Thread;

/**
 * @description:
 * @author: liSen
 * @time: 2021/6/9 15:42
 */
public class ProductTest{
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Product product = new Product(clerk);
        Consumer consumer = new Consumer(clerk);
        product.setName("生产者1");
        consumer.setName("消费者1");
        product.start();
        consumer.start();
    }
}

class Product extends  Thread{
    private Clerk clerk = null;

    public Product(Clerk clerk) {
        this.clerk = clerk;
        System.out.println("开始生产");
    }

    @Override
    public void run() {
        while (true){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProductCount();
        }

    }
}

class Consumer extends Thread{
    private  Clerk clerk = null;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
        System.out.println("开始消费");
    }

    @Override
    public void run() {
        while (true){
            try {
                sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.subStractProductCount();
        }

    }
}

class Clerk{
    private int productCount =0;

    public synchronized void addProductCount(){
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+"---------"+"生产："+productCount);
            notify();//生产好就唤醒
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void subStractProductCount(){
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName()+"---------"+"消费："+productCount);
            productCount--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
blank_zio
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程总结
01-20
然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。 　而如果直接用Run方法，这只是调用一个...
2.8 zio入门——标准ZIO服务
齐梦星空
02-03 342
2.8 标准ZIO服务 在本章的前面，我们讨论了ZIO环境类型，但是我们还没有使用它来编写任何程序。 在本书的后面，我们将深入介绍环境，并说明该环境如何为依赖项注入问题提供全面的解决方案。 现在，我们将讨论ZIO为每个应用程序提供的基本服务以及如何使用它们。 服务提供了定义明确的接口，可以在测试环境和生产环境中以不同的方式实现这些接口。ZIO根据平台为所有应用程序提供四到五个不同的默认服务： 1.Clock。 提供与时间和计划有关的功能。 如果您正在访问当前时间或计划在将来某个时间进行计算，则使用此时间。
Delphi多线程总结
疯流人物
10-23 2615
多线程总体认识 当前程序是一个进程, 进程只是一个工作环境, 线程是工作者; 每个进程都会有一个启动线程(或叫主线程), 也就是说: 大量的编码都是写给这个主线程的; ExitThread(0); 退出主线程; 系统不允许一个没有线程的进程存在, 所以程序就退出了. ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可. ...
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4299
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
超详细，Python 多线程总结的太到位了
Python学习与数据挖掘
10-30 3947
B站同名【有温度的算法】已经上线想观看视频讲解的同学在文末点击【原文链接】直达B站多线程常用模板在实际处理数据时，因系统内存有限，我们不可能一次把所有数据都导出进行操作，所以需要批量导出依次操作。为了加快运行，我们会采用多线程的方法进行数据处理，以下为我总结的多线程批量处理数据的模板：import threading # 从数据库提取数据的类 class Scheduler():     def __init__(self):
python多线程总结
星空下的密码
08-09 6500
多线程总结 话说多线程认识让我恼火了一阵子，很是不习惯程序跳来跳去的执行，毫无时间和空间逻辑的感觉了，现在对我所见的总结一下吧，其实多线程呢在目前的语言中都是差不多，所以只要你理解了多线程在任何语言都是使用的，不同的就是语法不同而已吧  1. 多线程内幕： 什么是多线程，说白了就是多个线程并发的执行， 既然是并发执行，但是cpu是不可能同时执行多个线程吧，所以怎么办呢，其实是一个假象
Java多线程总结（超详细总结）
唯有努力，方可自信！
05-09 6878
Java多线程总结1.创建线程的方式方式1方式2方式3方式42.线程安全引出线程安全（卖票例子）解决方式方式一方式二 1.创建线程的方式 方式1 继承于Thread类 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 4. 通过此对象调用start() 例子：遍历100以内的所有的偶数 class MyThread extends Thread { //2. 重写Thread类的run()
java多线程总结
勿在浮沙筑高台
02-17 1万+
Java多线程总结 线程的概念 在开始学习编程时，我们写的程序都是顺序执行。 例如这个场景：我们正在烧水等水开，此时有人敲门，我们需要等水烧开再去开门，这是单线程顺序执行（容易造成阻塞）。那么多线程呢？在等水烧开的时候，有人敲门那么我们就是开门，之后继续去烧水。也就是事情没有被阻塞住。 我们在写顺序程序的时候其实是有一个线程的，并且只有一个线程。多个线程是为了合理利用cup,加快事情的...
多线程基本总结思维导图
qq_43251445的博客
03-25 1513
多线程基本总结思维导图
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java-学习多线程总结上
12-22
多线程 1. 多线程的基本概念 每一个正在执行的程序都是一个进程，资源只有一块，所以在同一时间段会有多个程序同时执行，但是在一个时间点上，只能由一个程序执行，多线程是在一个进程的基础之上的进一步划分，因为...
java虚拟机中多线程总结
08-25
在本篇内容中小编给大家分享的是关于java虚拟机中多线程的知识点总结内容，需要的朋友们参考学习下。
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
JavaSE专题-多线程总结.doc
06-03
多线程的常见问题总结分析 1、多线程技术介绍 2、主线程介绍 3、创建线程的方式 4、线程中的异常问题 5、线程运行状态 6、线程第二种创建方式 7、多线程练习 8、线程安全问题分析和解决 9、多线程细节 10、同步使用...
iOS 多线程总结
04-01
对iOS的多线程方式做的总结；Pthreads,NSThread,GCD,NSOperation/NSOperationQueue
C# 多线程总结
05-05
C# 多线程总结，比较详细和全面，包含多种方式的多线程方法的说明。
JAVA多线程总结
03-06
JAVA多线程总结
python qt刷新_浅谈PyQt5中异步刷新UI和Python多线程总结
最新发布
05-26
以下是一些Python多线程的总结： 1. 线程的创建和启动 使用threading模块的Thread类可以创建线程对象，并使用start()方法来启动线程。 ``` import threading def worker(): # do some work pass t = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值