精华内容
下载资源
问答
  • 多线程的好处

    2019-10-09 02:25:48
    多线程的好处: 更好的资源利用 在某些场景下程序的设计会更简单 提升程序的响应性 多线程是实现高并发程序的一种手段。 转载于:https://www.cnblogs.com/myitnews/p/11420479.html...


    多线程的好处:

    • 更好的资源利用
    • 在某些场景下程序的设计会更简单
    • 提升程序的响应性

    多线程是实现高并发程序的一种手段。

    转载于:https://www.cnblogs.com/myitnews/p/11420479.html

    展开全文
  • 线程多有什么好处?提高CPU利用率,更好地利用系统资源,使用Monitor类可以同步静态/实例化方法全部...多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同制线程来执行不同任务,允许单...

    线程多有什么好处?提高CPU的利用率,更好地利用系统资源,使用Monitor类可以同步静态/实例化的方法的全部代码或者部分代码段,使用不同的同步类创建自己的同步机制。

    14b27ec96385a12fad106fb791198172.png

    多线程指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程提升整体处理性能。多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同制的线程来执行不同的任务,允许单个程序创建多个并行执行的线程来完成各自的任务。

    多线程的好处提高CPU的利用率。在多线程程序中,一个线程必须等待的时候,CPU可以运行其它的线程而不是等待,大大提高程序的效率。

    一、多线程优势

    采用多线程技术的应用程序可以更好地利用系统资源。主要优势在于充分利用了CPU的空闲时间片,用尽可能少的时间来对用户的要求做出响应,使得进程的整体运行效率得到较大提高,同时增强了应用程序的灵活性。由于同一进程的所有线程是共享同一内存,所以不需要特殊的数据传送机制,不需要建立共享存储区或共享文件,从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。

    线程同步,在多线程应用中,考虑不同线程之间的数据同步和防止死锁。当两个或多个线程之间同时等待对方释放资源的时候就会形成线程之间的死锁。为了防止死锁的发生,需要通过同步来实现线程安全。在Visual Basic中提供了三种方法来完成线程的同步。在Java中可用synchronized关键字。

    二、代码域同步

    使用Monitor类可以同步静态/实例化的方法的全部代码或者部分代码段。

    三、手工同步

    可以使用不同的同步类创建自己的同步机制。这种同步方式要求你自己手动的为不同的域和方法同步,这种同步方式也可以用于进程间的同步和解除由于对共享资源的等待而造成的死锁。

    四、上下文同步

    使用SynchronizationAttribute为ContextBoundObject对象创建简单的,自动同步。这种同步方式仅用于实例化的方法和域的同步。所有在同一个上下文域的对象共享同一个锁。

    总结多线程的好处,使用线程可以把占据时间长的程序中的任务放到后台去处理;用户界面更加吸引人,这样比如用户点击了一个按钮去触发某件事件的处理,可以弹出一个进度条来显示处理的进度;程序的运行效率可能会提高;在一些等待的任务实现上如用户输入,文件读取和网络收发数据等,线程就比较有用了.

    展开全文
  • 多线程的好处与弊端 什么是多线程? 线程:就是进程中一个负责程序执行的控制单元(执行路径) 一个线程中可以多执行路径,称之为多线程 一个进程中至少要有一个线程 开启多个线程是为了同时运行多部门代码 (例如:我们...

    多线程的好处与弊端

    什么是多线程?

    线程:就是进程中一个负责程序执行的控制单元(执行路径)
    

    一个线程中可以多执行路径,称之为多线程

    一个进程中至少要有一个线程

    开启多个线程是为了同时运行多部门代码
    (例如:我们打开qq的同时,听音乐,以及玩游戏等)

    每一个线程都有自己的内容,这个内容可以称为多线程要执行的任务
    .
    .
    .
    .
    .

    JAVA中虚拟机(JVM)中多线程解析

    在Java中,JVM(虚拟机)启动时就启动了多个线程,至少有两个线程可以分析的出来

         1.执行main函数的线程
                该线程的任务代码都定义在main函数中
         2.负责垃圾回收的线程
    

    我们都自动代码mian函数开始依次向下执行的…
    但是这段代码确不会…

    例子:

    class Demo extends Object
    {
        public void finalize()
        {
            System.out.println("demo ok");
        }
    }
    public class day12_09 {
        public static void main(String[] args)
        {
            new Demo();
            new Demo();
            new Demo();
            System.gc();
            System.out.println("Hello World");
        }
    }
    

    执行多次的结果:

    在这里插入图片描述
    在这里插入图片描述
    这里我们调用了继承了Object类,调用了它的finalize()以及System.gc()的方法
    告诉jvm执行垃圾回收机制,回收堆里面的垃圾(这里要记住的时,我们只是负责告诉它而已,至于它什么时候执行我们不知道)
    所以就出现了上面的情况了…

    这也能侧面证明我们上面的那个论点了
    .
    .
    .
    .

    多线程的好处与弊端

    多线程的好处: 解决了部分同时运行的问题
    (就是我们可以一边听歌,一边运行360,一边运行qq,微信等)

    多线程的弊端: 线程太多会导致效率的降低
    (就是我们开了太多的软件,导致我们的cpu要执行的切换就多了,会导致我们电脑变卡)

    其它应用程序的执行都是cpu在做着快速的切换完成,这个切换是随机的
    如果应用太多,它的速度就变慢了.

    展开全文
  • 多线程的好处? 创建线程的三种方式 线程常用方法

    Java基础-多线程基础概念

    前言:多线程系列拖到现在,也该复习下
    这个东西怎么说呢,也是非常常见。而且面试基本上是必问的(好吧,这是我复习的主要目的)
    一共预计会有6篇,这是第一篇

    推荐书籍:通过博客来理解多线程总会缺失点什么,毕竟每个人写的博客水平有不同。而且有些信息被加工后可能并不适合你
    《Java核心技术 卷Ⅰ》 这本书不止是线程,其实每章内容都不错。而且对Java水平有比较大的提升
    《Java编程思想》 这本书对Java水平提升帮助很大,但是老实说,感觉多线程那一篇内容很全,但是文章很乱
    《Java并发编程的艺术》 多线程相关鼎力推荐

    还有种好的方式就是用IDEA,通过ctrl+B快捷键直接追溯源码。不需要一字一句的去理解源码(太费时间)。看输出删除,返回值。或者其他想知道的东西。而且能看到继承,实现关系。这种方式收益也挺大
    多线程相关类或接口 :Thread Runnable Callable FutureTask

    大纲脑图
    多线程脑图

    1. 线程简介

    本段简单介绍什么是线程,进程。线程的状态,状态转换,以及线程优先级

    1.1 线程与进程

    进程 是资源分配的最小单元,一个进程可以有多个线程
    线程 是资源调度的最小单元,同一个进程下,各个线程的内存质押共享,所以线程间的通信代价小。线程也称为轻量进程

    1.2 为什么使用多线程

    • 对于多CPU,多核的来说,多线程能提高程序响应速度。相当几个人做同时开工,肯定比一个人快。(但是这个也不一定,因为线程调度,分配资源都需要开销。就像一个项目组5-10个人效率,可能比20-100个人效率更高,因为开会,信息共享都需要大量时间)
    • 对于单CPU单核机器(这种情况可能更常见)来说,因为有阻塞的存在,多线程效率能够更好。主要是磁盘太慢,如果是单线程,可能磁盘在007,CPU却大多数时间在喝茶。如果运行在内存中,单线程可能会更好,没有上下文切换的额外开销(例如 Redis)
    • 有些场景,多线程实现起来简单。例如游戏,不同的角色同时在做不同的事情,用单线程就很难处理这种情况

    单线程相当于顺序结构,一次做一件事,这件事情做完了(即使这件事中途可能要等待好久)才能做另外一件事情。
    多线程相当于在一个时间段内,做几件事情

    有些时候多线程好:一般是有些事情等待时间长,可以中途做其他事情
    有些时候单线程好:例如我想8个小时写3篇博客,肯定是单线程好,如果中途切换着写,可能思路就没了

    1.3 线程状态

    Java的线程状态和操作系统的不一样
    线程状态
    Java线程转换,其实我觉得理解其每个状态的意思就自然知道装换规则了。不用可以去记忆,没必要

    • New 新建状态
    • Runnable 可运行,代表线程可以被运行,可能正在运行,也可能等待时间片的过程中
    • Waiting 等待 因为调用了wait而暂停。注意与Blocked区分
    • Time_Waiting 计时等待,调用了sleep和wait后暂停,等待固定的时间后,进入可运行状态
    • Blocked 阻塞 因为缺少某些资源被迫不能运行
    • Terminated 终止状态 线程完成,或者说某些原因线程挂了(功成身退与中途陨落)

    1.4 线程优先级

    Java线程可以通过 getPriority()与setPriority() 获取和设置线程优先级
    Java线程有10个优先级。默认为5。优先级是有操作系统觉得的,其实在Java程序设置了优先级,也没什么卵用,因为操作系统不认(3月份HB的绿码,BJ也不认啊)
    windows有7个优先级

    1.5 守护线程

    守护线程,在《Java编程思想》里叫后台线程,为其他线程服务的线程,例如垃圾回收线程
    可以通过 setDaemon()将线程设置为守护线程

    2. Java线程相关操作

    2.1 Java创建线程的三种方式

    方式1: 继承Thread类,重写run()方法来创建线程

       // 创建线程方式一:继承Thread类,重写Run方法
        class ThreadChild extends Thread{
            @Override
            public void run() {
                super.run();
                int length = 100;
                Thread.currentThread().setName("方式一:继承Thread方式实现线程");
                for (int i = 0; i < length; i++){
                    System.out.println("这是以方式壹实现的线程,循环体i的值为" + i);
                }
            }
        }
    

    方式2: 实现Runnable接口,重写run()方法

    // 创建线程方式二:实现Runnable接口,重写Run方法
        class ThreadRunnable implements Runnable{
            @Override
            public void run() {
                int length = 300;
                Thread.currentThread().setName("方式二:实现Runnable接口方式实现线程");
                for (int i = 200; i < length; i++){
                    System.out.println("这是以方式二实现的线程,循环体i的值为" + i);
                }
            }
        }
    

    方式3: 实现Callable接口,重写call()方法

    // 创建线程方式三:实现Callable接口,重写Call方法
        class ThreadCallable implements Callable{
    
            @Override
            public Object call() throws Exception {
                int length = 900;
                Thread.currentThread().setName("方式3:实现Callable接口方式实现线程");
                for (int i = 800; i < length; i++){
                    System.out.println("这是以方式三实现的线程,循环体i的值为" + i);
                }
                // 我没有什么需要返回的,有点尴尬
                return null;
            }
        }
    

    三种方式对比

    方式一-继承Thread类的方式尽量少用,一般来说继承太过于重量级(继承子类用于所有父类公有的域,方法),实现接口的方式比继承好。
    一般用方式二-实现Runnable接口的方式。如果有返回值就用方式三实现Callable接口

    Runable和Callable接口都只有一个方法run()。实现Callable接口的方式有返回值。而且需要和FutureTask 配合使用

    需要注意的是,启动线程用的start(),不是调用run方法 如果调用run就是调用普通方法

    全部类代码

    package com.java.basic.multithreading;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    /**
     * @author dengtiantian
     */
    public class ThreadTest {
    
        // 创建线程方式一:继承Thread类,重写Run方法
        class ThreadChild extends Thread{
            @Override
            public void run() {
                super.run();
                int length = 100;
                Thread.currentThread().setName("方式一:继承Thread方式实现线程");
                for (int i = 0; i < length; i++){
                    System.out.println("这是以方式壹实现的线程,循环体i的值为" + i);
                }
            }
        }
    
        // 创建线程方式二:实现Runnable接口,重写Run方法
        class ThreadRunnable implements Runnable{
            @Override
            public void run() {
                int length = 300;
                Thread.currentThread().setName("方式二:实现Runnable接口方式实现线程");
                for (int i = 200; i < length; i++){
                    System.out.println("这是以方式二实现的线程,循环体i的值为" + i);
                }
            }
        }
    
        // 创建线程方式三:实现Callable接口,重写Call方法
        class ThreadCallable implements Callable{
    
            @Override
            public Object call() throws Exception {
                int length = 900;
                Thread.currentThread().setName("方式3:实现Callable接口方式实现线程");
                for (int i = 800; i < length; i++){
                    System.out.println("这是以方式三实现的线程,循环体i的值为" + i);
                }
                // 我没有什么需要返回的,有点尴尬
                return null;
            }
        }
    
        public static void main(String[] args) {
            ThreadTest threadTest = new ThreadTest();
            threadTest.testThread();
        }
    
        // 测试
        public void testThread(){
            ThreadChild threadChild = new ThreadChild();
            ThreadRunnable threadRunnable = new ThreadRunnable();
            ThreadCallable threadCallable = new ThreadCallable();
            //方式一开始运行
            threadChild.start();
            //方式二开始运行
            (new Thread(threadRunnable)).start();
            //方式三运行
            FutureTask<Object> task = new FutureTask<>(threadCallable);
            (new Thread(task)).start();
        }
    
    }
    
    

    2.2 线程相关常用方法

    去看源码或者API最自在,我这个也是从里面复制的

    2.2.1 Object线程相关方法

    • public final void wait() throws InterruptedException 暂停线程 会释放锁
    • public final native void notify();随机唤醒一个线程
    • public final native void notifyAll() 唤醒所有线程

    这三个方法都是Object的,我记得有个很常见的问题是:wait和sleep的区别
    这个是利用每个对象本身自带的锁实现的。都是本地方法
    notify()这个方法其实用的少,因为是随机唤醒一个线程,他自己也不知道唤醒的谁

    2.2.2Thread相关常用方法

    • getXXX系列方法
    • setXXX系列方法
    • public void interrupt() 中断 试图停止线程
    • public static boolean interrupted()测试线程是否被中断
    • public synchronized void start() 启动线程
    • public static native void sleep(long millis) throws InterruptedException 休眠,不会释放锁
    • public final void stop() 停止线程,已被放弃
    • public final void suspend()暂停线程,已被放弃
    • public final void resume() 唤醒线程,已被放弃
    • public static native void yield() 让出锁和时间片,如果他的优先级还是最高,那么他还会抢到锁

    3. 线程间协作

    其实这个标题当时其实是线程间的通信,后面改成同步。最后是这个
    反正这节 目的是为了表达线程之间工作关系
    重复:线程是共享内存,所以通信代价很低,但是这也有问题。
    举个例子:父亲剥柚子,儿子吃柚子。这两个动作是可以同时进行的(在已有剥好的前提下。) 儿子吃柚子得在有柚子可以吃的前提下,就是父亲有剥好的柚子。就是得剥好才能吃(你可不要说不剥儿子就吃,我敬你是条汉子)。本节就是说明线程的协作关系。
    以及还有父亲,儿子都吃瓜子。两种是竞争关系,得有瓜子才行

    3.1 Synchronized和Volatile机制

    Synchronized 是通过对某个共享的资源加锁,是这个资源一次只能被一个资源消耗者使用(利用对象锁,下章节详细写)
    Volatile相当于,对某个资源的操作一旦发生,马上所有关注这个资源的用户都知晓(内存模型里讲最好)

    3.2 等待通知机制

    利用wait和notifyAll方法,对于有一定先后关系的操作,一旦 后者先执行了,马上wait,然后先者,执行后notifyAll唤醒后者消费

    3.3 使用管道通信

    我不记得Java管道知识点了,有点尴尬。后续补上

    聊下Redis的管道和操作系统的管道缓解下尴尬
    Redis的管道有点类似于JDBC里面的addBatch()和累积发送(数据攒到一定量在传输)。就是说Redis的管道为了提高效率,将多条命令攒到一起提交给服务器执行
    Linux的管道相当于提供一个中间文件,线程或进程将数据放到管道,然后另外的线程或进程从管道获取数据。其实也是表明了一种先后的顺序,虚拟机里面happen-before那味儿。

    3.4 ThreadLocal的使用

    这个其实线程有些数据不想共享给别的线程,就相当于局部变量。知道这个我觉得就好了,其实没什么特殊的,具体用法用的时候查看具体的API或者看源码(ctrl+b)就好了。我不明白为什么很多有很多文章特意提这个

    4. 小结

    1. 什么是线程,线程与进程的区别
    2. 多线程的好处。多线程一定快吗?(需要知道上下文切换是有消耗的)
    3. 创建线程的三种方式
    4. 线程相关的方法

    总目录:Java进阶之路-目录

                    天高地迥,觉宇宙之无穷。兴尽悲来,识盈虚之有数
                    《滕王阁序》 王勃
                    博主:五更依旧朝花落
                    首次发布时间:2020年4月18日17:24:53
                    末次更新时间:
    
    展开全文
  • 我相信每个人都必须非常好奇,Redis6.0中多线程的好处是什么?让我们分析一下一对一介绍多线程的许多好处〜 1、解决单线程的局限性 我们都知道Redis之前没有引入多线程是因为单线程的使用具有很高的可维护性,这与...
  • OpenMP与C++ 事半功倍地获得多线程的好处
  • 多线程的好处与弊端

    万次阅读 2020-01-27 21:36:32
    在创建线程之前先说明一下基本概念: 串行与并行: ...线程:CPU调度和分配基本单位,基本不用系统资源,只拥有一点在运行时必不可少资源(大约占用1M内存) 进程:应用程序一次执行过程 线程与进程之间...
  • 几乎所有操作系统都支持同时运行个任务,一个任务通常就是一个程序,每一个运行中程序就是一个进程。当一个程序运行时,内部可能包含个顺序执行流,每一个顺序执行流就是一个线程线程和进程几乎所有操作...
  • 1.进程:是程序一次执行过程,或是正在运行一个程序 。由程序、数据和进程控制块三部分组成。...线程共享进程全部系统资源,同时线程还拥有自己独立程序计数器、虚拟机栈、本地方法栈。 总结:一个...
  • 使用多线程的好处

    千次阅读 2014-08-12 20:35:11
    1.耗时的操作使用线程,提高应用程序响应 2.并行操作时使用线程,如C/S架构的服务器端并发线程响应用户的请求。... 使用多线程的理由之一是和进程相比,它是一种非常花销小,切换快,更"节俭"的多任务操
  • OpenMP与C++:事半功倍地获得多线程的好处(上) KangSu Gatlin & Pete Isensee 著 赖勇浩 译 在并行计算领域有一个广为流传的笑话——并行计算是未来之事并且永远都是。这个小笑话几十年来一直都是对的。一种...
  • 一、为什么要使用多线程多线程真的能提高效率吗? 1.1为什么要使用多线程 多线程编程的目的,就是"最大限度地利用CPU资源",当某一线程的处理不需要占用CPU而只和I/O等资源打交道时,让需要占用CPU资源...
  • 多线程编程的目的,就是“最大限度地利用CPU资源”,当某一线程的处理不需要占用CPU而只和I/O等资源打交道时,让需要占用CPU资源的其它线程有机会获得CPU资源。从根本上说,这就是多线程编程的最终目的。因为单线程...
  • 使用线程的好处有以下几点: ·使用线程可以把占据长时间的程序中的任务放到后台去处理 ·用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度 ·程序的...
  • java多线程的好处.1

    千次阅读 2016-04-14 21:13:15
    进程和CPU之间关系并不是同时进行,一个CPU一次只能执行一个进程,那为什么任务管理器中有那么进程呢? 因为这些进程他们是一直在“争抢”CPU控制权,没出错,是“争抢”,哪个进程此时抢
  • 尽管面临种种挑战,多线程仍被使用是以为如下一些好处: 更好资源利用性。在某些情况下更简单程序设计。程序响应性更强。 更好资源利用性 设想一个从本地文件系统读取和处理文件应用程序。假设从...
  • 即使编写多线程程序具有挑战性,但它仍在使用中,是因为它可以带来如下的好处: 更好的资源利用 在某些场景下程序的设计会更简单 提升程序的响应性 更好的资源利用 假设一个应用会从本地文件系统中读取和...
  • 不多说,直接上干货!...牛客网Java刷题知识点之进程和线程的区别 什么是多线程?  一个进程中可以多执行路径,称之为多线程。  一个进程中至少要有一个线程。  开启多个线程是为了同时运行多...
  • 一个进程中可以多执行路径,称之为多线程。 什么是多线程?  一个进程中至少要有一个线程。  开启多个线程是为了同时运行多部分代码。 每一个线程都有自己运行内容。这个内容可以称为线程要执行任务。  其实...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,042
精华内容 2,416
关键字:

多线程的好处