对于多线程知识的总结（超详细）

最新推荐文章于 2024-01-02 11:10:14 发布
最新推荐文章于 2024-01-02 11:10:14 发布
阅读量334 收藏 1
点赞数 1
分类专栏： java多线程知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62445683/article/details/124432604
版权

大家好，我是忘鱼。这期干货满满，多线程从浅到深的讲解。

目录

一、多线程的三种建立方式。

二、Thread常用方法。

1,Thread.currentThread().getName();

2，Thread.sleep()；

三、线程安全问题，原因与解决方案。

1、模拟线程安全问题案例：取款。

2、解决方案：三种，同步代码块，同步方法，同步锁。

四、线程池（很重要的知识）

1，创建线程池

方法一：ExecutorServive

方法二：Executors

五、线程池处理Runnable与Callable任务。

1,简单的案例处理

六、定时器

1、Timer实现

2、scheduledExecutorService实现

七、多线程并发并行，与生命周期。

1、并发就是。

2、并行就是。

3、生命周期

八，总结

一、多线程的三种建立方式。

//建立多线程方法1
public class ThreadDemo1 {
    public static void main(String[] args) {
      Thread t=new Mythread();
      t.start();
        for (int i = 0; i < 5; i++) {

            System.out.println("主线程执行了"+i);
        }


    }
 static class Mythread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {

                System.out.println("子线程执行了"+i);
            }
        }
    }
}
//建立方式二，
public class ThreadDemo2 {
    public static void main(String[] args) {
       Runnable th=new MyRunnable();
       Thread t=new Thread(th);
        t.start();
        Runnable th2=new MyRunnable();
        Thread t2=new Thread(th2);
        t2.start();
//    两个线程近似看做同时执行。
        for (int i = 0; i < 5; i++) {

            System.out.println("主线程执行了"+i);
        }
    }
 static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {

                System.out.println(Thread.currentThread().getName()+"子线程执行了"+i+"---------"+System.nanoTime());
            }
        }
    }
}
//还是方式2，多了匿名类部类。
//建立多线程方法2匿名类部类
public class ThreadDemo02 {
    public static void main(String[] args) {
Runnable th=new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行了"+i);
        }
    }
};
Thread t=new Thread(th);
t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了"+i);
        }
    }

}
//建立方式3，算个例题吧
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo3 {
    public static void main(String[] args) {
        Callable<String> call=new MyCallable(100);
        FutureTask<String> task = new FutureTask<>(call);
        Thread t = new Thread(task);
        t.start();
        Callable<String> call2=new MyCallable(200);
        FutureTask<String> task2 = new FutureTask<>(call2);
        Thread t2 = new Thread(task2);
        t2.start();
//两个子线程同时执行，主线程

        try {
            String t1=task.get();
            System.out.println("第一个线程结果"+t1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String t12=task2.get();
            System.out.println("第二个线程结果"+t12);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    static class   MyCallable implements Callable<String>{
        private int  n;

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

        int sum=0;
        @Override
        public String call() throws Exception {
            for (int i = 1; i <=n ; i++) {
                sum+=i;
            }
            return "子线程执行结果"+sum;
        }
    }
}

二、Thread常用方法。

1,Thread.currentThread().getName();

     获取当前线程名字，与那个获取当前对象this道理一样。

2，Thread.sleep()；

     执行到此处休眠，括号内是毫秒。

三、线程安全问题，原因与解决方案。

1、模拟线程安全问题案例：取款。

2、解决方案：三种，同步代码块，同步方法，同步锁。

         案例、线程出现安全问题，是由于多个线程同时处理同一资源，导致出错如：给个案例谈谈。比如说小兰与小花共同有一个账户，里面有10万元，她们同时取钱出现了小兰与小花都取了10万，卡里所剩-10万。

当然解决方案有三种，代码块里面会显示。看代码

public class ThreadDemo {
    public static void main(String[] args) {
        Account acc=new Account("1298323",100000.0);
        new DrawThread(acc,"小兰").start();
        new DrawThread(acc,"小花").start();

    }
}



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);
    }
}



import javax.sound.sampled.Line;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String cardid;
    private double money;
private final Lock lock=new ReentrantLock();
    public Account() {
    }
    public void drawMoney(double money) {
        String name=Thread.currentThread().getName();
            if(this.money>=money){
                System.out.println("恭喜"+name+"取走了钱:"+money);
                this.money-=money;
                System.out.println("所剩余额："+this.money);
            }else {
                System.out.println("余额不足");
            }
        }
//解决方案一
    /*public void drawMoney(double money) {
        String name=Thread.currentThread().getName();
        synchronized (this) {
            if(this.money>=money){
                System.out.println("恭喜"+name+"取走了钱:"+money);
                this.money-=money;
                System.out.println("所剩余额："+this.money);
            }else {
                System.out.println("余额不足");
            }
        }
    }*/
//    解决方案2
    /*public synchronized void drawMoney(double money) {
        String name=Thread.currentThread().getName();

            if(this.money>=money){
                System.out.println("恭喜"+name+"取走了钱:"+money);
                this.money-=money;
                System.out.println("所剩余额："+this.money);
            }else {
                System.out.println("余额不足");
            }
        }
*/
//    解决方案3
    /*public void drawMoney(double money) {
        String name=Thread.currentThread().getName();
lock.lock();
        try {
            if(this.money>=money){
                System.out.println("恭喜"+name+"取走了钱:"+money);
                this.money-=money;
                System.out.println("所剩余额："+this.money);
            }else {
                System.out.println("余额不足");
            }
        } finally {    lock.unlock();

        }

        }
*/
    public Account(String cardid, double money) {
        this.cardid = cardid;
        this.money = money;
    }

    public String getCardid() {
        return cardid;
    }

    public void setCardid(String cardid) {
        this.cardid = cardid;
    }

    public double getMoney() {
        return money;
    }

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


}

四、线程池（很重要的知识）

1，创建线程池

方法一：ExecutorServive

使用ExecutorServive的实现类ThreadPoolExecutor自创建一个线程池对象，看代码

ExecutorService pool=new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

ThreadPoolExecutor里面的一些变量分别是，核心线程，最大线程，临时线程最大存活时间，时间单位，指定任务队列最大数，指定线程工厂默认的就行，这过参数有4种选择看需求。

方法二：Executors

使用Executors（线程池工具类）调用方法创建对象。

这个容易出现bug，不推荐，阿里巴巴java，也是不推荐的。

五、线程池处理Runnable与Callable任务。

1,简单的案例处理

public class MyRunnable implements Runnable{

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



import java.util.concurrent.*;

/*int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler*/
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService pool=new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
       Runnable t=new MyRunnable();
        pool.execute(t);
        pool.execute(t);
        pool.execute(t);
        pool.execute(t);
        pool.execute(t);

    }
}

Callable与Runnable处理基本一样，不过Callable多了个可以调用get方法取值，与上面创建线程第三种那get用法基本一致。

六、定时器

1、Timer实现

直接创建对象，写就完了，这种问题容易出现，不推荐，推荐第二种。

 Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("www");
            }
        },0,2000);

2、scheduledExecutorService实现

 ScheduledExecutorService s=new ScheduledThreadPoolExecutor(3);
        s.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+ "定时输出:aiiaiiaiai"+new Date()+System.currentTimeMillis());
            }
        },0,2, TimeUnit.SECONDS);

这种创建定时器比较好，就用这。

七、多线程并发并行，与生命周期。

1、并发就是。

线程在间隔极短的时间执行了，看做是同时执行，我算了算大概到纳米级才会出现，时间差异。毫秒级都是看做同时执行的，很夸张了。

2、并行就是。

线程在同一时刻同时执行，不存在时间差的。

3、生命周期

就是线程的生命周期官方提供了6种。

八，总结

加油努力，相信自己。

忘忘忘忘忘鱼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
深度剖析Java多线程，由浅至深
qq_46601365的博客
08-03 294
Java多线程 引入 我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决。 并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时
多线程由浅入深，干货满满
liumeina_study的博客
06-29 97
多线程由浅入深，线程的两种创建方式，Thread类的基本方法，线程的同步(synchronized)，线程的调度（sleep,yield,join,interrupt,经典的银行存取款问题，线程死锁，以及生产者和消费者(主要是wait和notify的状态切换)等代码实现），代码实现范例汇总
多线程的由浅及深
laoyog
07-19 276
1. 进程和线程 进程：当一个程序进入内存中运行，就是一个进程。所以每个进程都有单独的分配内存。典型的特征就是进程的pid，可以通过kill命令杀死进程。比如运行的每个软件就是每个进程。 线程：进程的一个执行单位，也是CPU调度的基本单位。一个进程会有多条线程，线程共享进程的所有上下文环境，在多进程时，CPU会不断的切换线程来执行(同一时间cpu只会执行一个线程，但cpu的速度很快，给人同时...
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 1902
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
多线程知识汇总
sduihoal的博客
03-24 239
思维导图 一、认识多线程——要点解析 1、多线程的创建方法 （1）继承Thread重写run() class MyThread extends Thread { @Override public void run() { System.out.println("这里是线程运行的代码"); } } MyThread t = new MyThread(); t.start(); // 线程开始运行...
Java基础知识总结（超详细整理）
02-02
本套笔记循循渐进，适合初入计算机行业的小白，从Java概述到语法，再到循环，数组，方法，面向对象，继承，多态，内部类，集合，异常，IO流，多线程，网络编程，Lambda表达式，最后是类加载器，反射，模块化。...
java多线程编程总结
01-09
java多线程编程总结，超级细致与权威，我看过的最好的理解多线程知识点的复习资料
一份超级详细的Java面试题【大厂面试真题+Java学习指南+工作总结】.zip
最新发布
01-03
Java核心技术：如多线程、网络编程、序列化等都有详细的解释和示例。 常用框架：如Spring、MyBatis等框架的使用方法和内部原理都有涉及。 数据库相关：包括关系型数据库和非关系型数据库的使用，以及JDBC、MyBatis等...
asp.net知识库
06-18
关于能自定义格式的、支持多语言的、支持多数据库的代码生成器的想法 发布Oracle存储过程包c#代码生成工具(CodeRobot) New Folder XCodeFactory3.0完全攻略－－序 XCodeFactory3.0完全攻略－－基本思想 XCodeFactory...
多线程知识
时光
04-07 246
java多线程
多线程的知识点
qq_62086657的博客
05-27 355
多线程、进程、synchronize、生产者与消费者模式、wait（）方法、sleep（）方法、线程生命周期、yield（）方法、jion（）方法、notify（）方法、线程同步与互斥、锁
多线程知识点总结（通俗易懂）
haoyueONEX的博客
01-02 841
多线程
多线程总结
weixin_60934893的博客
02-07 412
当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。
【多线程】多线程基础知识
吞吞吐吐大魔王的博客
08-15 1145
Runnable 接口时线程辅助类，仅定义了一个 fun() 方法。该方法中描述了要实现的线程的内容。
多线程相关知识点
weixin_48304192的博客
04-19 237
多线程知识点总结 1.进程与线程 1.1什么是进程 程序是静止的，只有真正运行时的程序，才被称之为进程。 单核CPU在任何时间点上，只能运行一个进程：宏观并行，微观串行。 1.2什么是线程 线程，又称轻量级进程(Light Weight Process)。程序中的一个顺序控制流程，同时也是CPU调度的基本单位。进程由多个线程组成，彼此间完成不同的工作，交替执行，成为多线程。 迅雷是一个进程，当中的多个下载任务即是多个线程。 Java虚拟机是一个进程，当中默认包含主线程(Main)，可通过代
多线程基础
weixin_52754604的博客
09-13 170
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。
多线程知识总结
持续Java学习中
01-17 734
多线程 1、线程简介 1、关键字：任务、进程、进程、多线程 2、普通方法调用和多线程 3、核心概念 线程是独立的执行路劲 在程序运行时，及时没有自己创建线程，后台也会有多个线程，如主线程，gc线程 main()称之为主线程，为系统的入口，用于执行整个程序 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与OS密切相关的，先后顺序是不能人为的干预的 对于同一份资源操作时...
.net 多线程编程知识点 说详细点
04-01
1. 线程基础知识：线程是操作系统分配CPU时间片的最小单位，多线程就是指同时运行多个线程，可以提高程序的执行效率和响应速度。 2. 线程同步：多个线程访问共享资源时需要进行同步，常用的同步方式有锁、信号量、事件等，在多线程编程中需要注意同步问题，避免出现死锁、竞争等问题。 3. 线程池：线程池是一种管理和复用线程的机制，可以避免频繁创建和销毁线程的开销，提高程序性能。 4. 异步编程：异步编程是一种高效的多线程编程方式，可以避免阻塞主线程，提高程序的响应速度和吞吐量，常用的异步编程方式有回调、任务、异步/await等。 5. 并发集合类：并发集合类是一种线程安全的数据结构，可以在多线程环境下安全地访问和修改集合中的元素，常用的并发集合类有ConcurrentQueue、ConcurrentDictionary等。 6. 线程调试：多线程编程中常常会出现难以重现或者难以查找的问题，需要使用调试工具进行线程调试，常用的调试工具有Debug、Trace等。 7. 线程性能优化：多线程编程中需要注意性能问题，可以通过调整线程数、使用线程池、优化同步方式等方式提高程序性能。 8. 线程安全性：多线程编程中需要注意线程安全性问题，避免出现数据竞争、死锁、线程泄漏等问题，提高程序的可靠性和稳定性。 9. 并发编程模型：并发编程模型是一种用于描述多线程编程模式的方式，常用的模型有Actor模型、CSP模型、数据流模型等。 10. 并行计算：并行计算是一种高效的计算方式，可以将任务分配到多个线程中执行，常用的并行计算方式有MapReduce、OpenMP、CUDA等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值