精华内容
下载资源
问答
  • 单线程和多线程

    2020-11-04 22:13:24
    单线程和多线程 单线程 普通的程序默认都是单线程,程序的执行方式是从上至下串行执行,示例 import time def func(a,b): time.sleep(1) print(a+b) s = time.time() func(5,10) func(2,5) func(6,84) func(9,46) ...

    单线程和多线程

    单线程

    普通的程序默认都是单线程,程序的执行方式是从上至下串行执行,示例

    import time
    def func(a,b):
        time.sleep(1)
        print(a+b)
    s = time.time()
    func(5,10)
    func(2,5)
    func(6,84)
    func(9,46)
    e = time.time()
    print(f'执行时间:{e-s}s')
    

    执行结果:可以看到其结果和代码的打印顺序对应

    H:\Python虚拟环境\Spyder\Scripts\python.exe H:/Day7Thread/test.py
    15
    7
    90
    55
    执行时间:4.036719799041748s
    
    Process finished with exit code 0
    
    

    多线程

    import time()
    from threading import Thread
    def func(a,b):
        time.sleep(1)
        print(a+b)
    #创建线程对象
    t1 = Thread(target=func,args=(5,10))
    t2 = Thread(target=func,args=(2,5))
    t3 = Thread(target=func,args=(6,84))
    t4 = Thread(target=func,args=(9,46))
    s = time.time()
    #启动子线程
    t1.start()
    t2.start()
    t3.start()
    t4.start()
    #等待子线程执行完成
    t1.join()
    t2.join()
    t3.join()
    t4.join()
    e = time.time()
    print(f'执行时间{e-s}s')
    

    执行结果:执行时间是单线程的1/4,且打印顺序和单线程不一样,这是因为多线程在执行的时候是并发执行的,哪个子线程线执行结束是不确定的

    H:\Python虚拟环境\Spyder\Scripts\python.exe H:/Day7Thread/test.py
    55
    15
    7
    90
    
    执行时间1.0107004642486572s
    
    Process finished with exit code 0
    
    
    展开全文
  • Java单线程和多线程

    2019-08-22 21:41:50
    Java单线程和多线程 线程 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组...

    Java单线程和多线程

    线程

    线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

    线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。

    单线程

    单线程在程序执行时,所走的程序路径按照连续顺序排下来,前面的必须处理好,后面的才会执行。单线程就是进程只有一个线程。

    多线程

    多线程指的是在单个程序中可以同时运行多个不同的线程,执行不同的任务。因为线程只能在单个进程的作用域内活动,所以创建线程比创建进程要廉价得多,同一类线程共享代码和数据空间,每个线程有独立的运行栈,线程切换的开销小。因此多线程编程在现代软件设计中被大量采用。

    线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的工作,称为多线程。

    在Java中要想实现多线程,有两种手段,一种是继承Thread类,另外一种是实现Runable接口。(其实准确来讲,应该有三种,还有一种是实现Callable接口,并与Future、线程池结合使用。)

    并发性(concurrency)和并行性(parallel)是不同的。并行指的是同一时刻,多个指令在多台处理器上同时运行。并发指的是同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行,看起来就好像多个指令同时执行一样。

    main方法其实也是一个线程。在java中所以的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的资源。

    在Java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候,实际上都会启动一个JVM,每一个JVM实际在就是在操作系统中启动了一个进程。

    线程状态

    新建的线程在它的一个完整生命周期中通常经历5种状态:新建状态、就绪状态、运行状态、阻塞状态、终止状态。
    在这里插入图片描述
    一个线程通过对象创建方式建立,线程对象通过调用start()方法进入到 “就绪状态” ,一个处于 “就绪状态” 下的线程将有机会等待调度程序安排CPU时间片进入到 “运行状态” 。
    在 “运行状态” 的线程根据情况有如下3种可能的走向:

    • 时间片执行时间用完它将重新回到 “就绪状态” ,等待新的调度运行机会。
    • 线程的run()方法代码执行完毕将进入到 “终止状态”
    • 线程可能因某些事件的发生或者等待某个资源而进入到 “阻塞状态”。阻塞条件解除后线程将进入 “就绪状态”
      在这里插入图片描述

    Thread类常用方法

    static Thread currentThread() 返回对当前正在执行的线程对象的引用。 
    long getId()返回该线程的标识符。 
    String getName()返回该线程的名称。 
    int getPriority() 返回线程的优先级。 
    void interrupt() 中断线程。 
    boolean isAlive()测试线程是否处于活动状态。 
    void join()等待该线程终止。 
    void join(long millis)等待该线程终止的时间最长为 millis 毫秒。 
    void join(long millis, int nanos)等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
    void setDaemon(boolean on)将该线程标记为守护线程或用户线程。 
    void setPriority(int newPriority)更改线程的优先级。 
    static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。 
    static void sleep(long millis, int nanos)在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。 
    void start() 使该线程开始执行;Java 虚拟机调用该线程的 run 方法。 
    static void yield()暂停当前正在执行的线程对象,并执行其他线程。
    

    单线程demo

    public class SingleThread {
        public static void main(String[] args){
    		Thread thread = Thread.currentThread(); // 获取当前运行的线程对象
    		thread.setName("单线程"); // 线程重命名
    		System.out.println(thread.getName() + "正在运行");
    		for (int i = 1; i <= 10; i++) {
    			System.out.println("线程正在休眠:" + i);
    			try {
    				Thread.sleep(1000); // 线程休眠,延迟一秒
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    				System.out.println("线程出错");
    			}
    		}
        }
    }
    

    输出结果:

    单线程正在运行
    线程正在休眠:1
    线程正在休眠:2
    线程正在休眠:3
    线程正在休眠:4
    线程正在休眠:5
    线程正在休眠:6
    线程正在休眠:7
    线程正在休眠:8
    线程正在休眠:9
    线程正在休眠:10
    

    继承Thread类实现多线程demo

    public class TestThread {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Thread t1 = new ExtendThread("t1", 1000); // 使用上转对象创建线程,并构造线程名字和线程休眠时间
    		Thread t2 = new ExtendThread("t2", 1000);
    		Thread t3 = new ExtendThread("t3", 1000);
    		t1.start(); // 启动线程并调用run方法
    		t2.start();
    		t3.start();
    	}
    
    }
    
    class ExtendThread extends Thread { // 继承Thread的类
    	String name;
    	int time;
    
    	public ExtendThread(String name, int time) { // 构造线程名字和休眠时间
    		this.name = name;
    		this.time = time;
    	}
    
    	public void run() { // 重写Thread类的run方法
    		for (int i = 1; i <= 3; i++) {
    			try {
    				sleep(time); // 所有线程加入休眠
    
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    				System.out.println("线程中断异常");
    			}
    			System.out.println("名称为:" + name + i + ",线程休眠:" + time + "毫秒");
    		}
    	}
    }
    

    输出结果:

    名称为:t11,线程休眠:1000毫秒
    名称为:t21,线程休眠:1000毫秒
    名称为:t31,线程休眠:1000毫秒
    名称为:t22,线程休眠:1000毫秒
    名称为:t12,线程休眠:1000毫秒
    名称为:t32,线程休眠:1000毫秒
    名称为:t13,线程休眠:1000毫秒
    名称为:t23,线程休眠:1000毫秒
    名称为:t33,线程休眠:1000毫秒
    

    实现Runnable接口的多线程demo

    public class RunnableThread {
        public static void main(String[] args){
            Runnable r1=new ImplRunnable("r1",1000); //Runnable接口必须依托Thread类才能创建线程
            Thread t1=new Thread(r1); //Runnable并不能调用start()方法,因为不是线程,所以要用Thread类加入线程
            Runnable r2=new ImplRunnable("r2",1000);
            Thread t2=new Thread(r2);
            Runnable r3=new ImplRunnable("r3",1000);
            Thread t3=new Thread(r3);
             
            t1.start(); //启动线程并调用run方法
            t2.start();
            t3.start();
        }
    }
    class ImplRunnable implements Runnable { // 继承Runnable接口的类
    	String name;
    	int time;
    
    	public ImplRunnable(String name, int time) { // 构造线程名字和休眠时间
    		this.name = name;
    		this.time = time;
    	}
    
    	@Override
    	public void run() { // 实现Runnable的run方法
    		for (int i = 1; i <= 3; i++) {
    			try {
    				Thread.sleep(time); // 所有线程加入休眠
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    				System.out.println("线程中断异常");
    			}
    			System.out.println("名称为:" + name + i+",线程休眠:" + time + "毫秒");
    		}
    	}
    }
    

    输出结果:

    名称为:r21,线程休眠:1000毫秒
    名称为:r11,线程休眠:1000毫秒
    名称为:r31,线程休眠:1000毫秒
    名称为:r22,线程休眠:1000毫秒
    名称为:r12,线程休眠:1000毫秒
    名称为:r32,线程休眠:1000毫秒
    名称为:r23,线程休眠:1000毫秒
    名称为:r13,线程休眠:1000毫秒
    名称为:r33,线程休眠:1000毫秒
    
    展开全文
  • 多线程编程 - 单线程和多线程执行对比 递归求斐波那契、阶乘与累加函数的执行。该脚本按照单线程的方式运行这三个函数,之后使用多线程的方式执行同样的任务,用来说明多线程环境的优点。 以单线程模式运行时,...

    多线程编程 - 单线程和多线程执行对比

    递归求斐波那契、阶乘与累加函数的执行。该脚本按照单线程的方式运行这三个函数,之后使用多线程的方式执行同样的任务,用来说明多线程环境的优点。

    myThread.py

    #!/usr/bin/env python3
    
    import threading
    from time import time, ctime
    
    
    class MyThread(threading.Thread):
        def __init__(self, func, args, name='', verb=False):
            threading.Thread.__init__(self)
            self.name = name
            self.func = func
            self.args = args
            self.verb = verb
    
        def getResult(self):
            return self.res
    
        def run(self):
            if self.verb:
                print('starting', self.name, 'at:', ctime())
    
            self.res = self.func(*self.args)
            if self.verb:
                print(self.name, 'finished at:', ctime())
    
    

    sample.py

    #!/usr/bin/env python3
    
    from myThread import MyThread
    from time import ctime, sleep
    
    
    def fib(x):
        sleep(0.005)
        if x < 2: return 1
        return (fib(x - 2) + fib(x - 1))
    
    
    def fac(x):
        sleep(0.1)
        if x < 2: return 1
        return (x * fac(x - 1))
    
    
    def sum(x):
        sleep(0.1)
        if x < 2: return 1
        return (x + sum(x - 1))
    
    
    funcs = (fib, fac, sum)
    n = 12
    
    
    def main():
        nfuncs = range(len(funcs))
    
        print('*** SINGLE THREAD')
        for i in nfuncs:
            print('starting', funcs[i].__name__, 'at:', ctime())
            print(funcs[i](n))
            print(funcs[i].__name__, 'finished at:', ctime())
    
        print('\n*** MULTIPLE THREADS')
        threads = []
        for i in nfuncs:
            t = MyThread(funcs[i], (n,), funcs[i].__name__, True)
            threads.append(t)
    
        for i in nfuncs:
            threads[i].start()
    
        print("thread.join()")
    
        for i in nfuncs:
            threads[i].join()
            print(threads[i].getResult())
    
        print('all DONE')
    
    
    if __name__ == '__main__':
        main()
    
    
    yongqiang@DESKTOP-6LEDFIJ:~$ ll
    total 13
    drwxr-xr-x 1 yongqiang yongqiang  512 May 12 12:29 ./
    drwxr-xr-x 1 root      root       512 Feb 24 17:54 ../
    -rw------- 1 yongqiang yongqiang  208 May 12 14:21 .bash_history
    -rw-r--r-- 1 yongqiang yongqiang  220 Feb 24 17:54 .bash_logout
    -rw-r--r-- 1 yongqiang yongqiang 3771 Feb 24 17:54 .bashrc
    ---------- 1 yongqiang yongqiang  590 May 12 13:50 myThread.py
    -rw-r--r-- 1 yongqiang yongqiang  655 Feb 24 17:54 .profile
    -rw------- 1 yongqiang yongqiang    7 May 12 12:28 .python_history
    ---------- 1 yongqiang yongqiang 1044 May 12 14:23 sample.py
    -rw-r--r-- 1 yongqiang yongqiang    0 May 12 12:29 .sudo_as_admin_successful
    yongqiang@DESKTOP-6LEDFIJ:~$
    yongqiang@DESKTOP-6LEDFIJ:~$ sudo chmod 777 ./myThread.py ./sample.py
    [sudo] password for yongqiang:
    yongqiang@DESKTOP-6LEDFIJ:~$
    yongqiang@DESKTOP-6LEDFIJ:~$ ll
    total 13
    drwxr-xr-x 1 yongqiang yongqiang  512 May 12 12:29 ./
    drwxr-xr-x 1 root      root       512 Feb 24 17:54 ../
    -rw------- 1 yongqiang yongqiang  208 May 12 14:21 .bash_history
    -rw-r--r-- 1 yongqiang yongqiang  220 Feb 24 17:54 .bash_logout
    -rw-r--r-- 1 yongqiang yongqiang 3771 Feb 24 17:54 .bashrc
    -rwxrwxrwx 1 yongqiang yongqiang  590 May 12 13:50 myThread.py*
    -rw-r--r-- 1 yongqiang yongqiang  655 Feb 24 17:54 .profile
    -rw------- 1 yongqiang yongqiang    7 May 12 12:28 .python_history
    -rwxrwxrwx 1 yongqiang yongqiang 1044 May 12 14:23 sample.py*
    -rw-r--r-- 1 yongqiang yongqiang    0 May 12 12:29 .sudo_as_admin_successful
    yongqiang@DESKTOP-6LEDFIJ:~$
    yongqiang@DESKTOP-6LEDFIJ:~$ python3 ./sample.py
    *** SINGLE THREAD
    starting fib at: Sun May 12 14:25:28 2019
    233
    fib finished at: Sun May 12 14:25:31 2019
    starting fac at: Sun May 12 14:25:31 2019
    479001600
    fac finished at: Sun May 12 14:25:32 2019
    starting sum at: Sun May 12 14:25:32 2019
    78
    sum finished at: Sun May 12 14:25:33 2019
    
    *** MULTIPLE THREADS
    starting fib at: Sun May 12 14:25:33 2019
    starting fac at: Sun May 12 14:25:33 2019
    starting sum at: Sun May 12 14:25:33 2019
    thread.join()
    sum finished at: Sun May 12 14:25:35 2019
    fac finished at: Sun May 12 14:25:35 2019
    fib finished at: Sun May 12 14:25:36 2019
    233
    479001600
    78
    all DONE
    yongqiang@DESKTOP-6LEDFIJ:~$
    
    /usr/bin/python3.5 /home/strong/workspace/sample.py
    *** SINGLE THREAD
    starting fib at: Sun May 12 17:10:27 2019
    233
    fib finished at: Sun May 12 17:10:29 2019
    starting fac at: Sun May 12 17:10:29 2019
    479001600
    fac finished at: Sun May 12 17:10:30 2019
    starting sum at: Sun May 12 17:10:30 2019
    78
    sum finished at: Sun May 12 17:10:32 2019
    
    *** MULTIPLE THREADS
    starting fib at: Sun May 12 17:10:32 2019
    starting fac at: Sun May 12 17:10:32 2019
    starting sum at: Sun May 12 17:10:32 2019
    thread.join()
    sum finished at: Sun May 12 17:10:33 2019
    fac finished at: Sun May 12 17:10:33 2019
    fib finished at: Sun May 12 17:10:34 2019
    233
    479001600
    78
    all DONE
    
    Process finished with exit code 0
    
    

    以单线程模式运行时,只是简单地依次调用每个函数,并在函数执行结束后立即显示相应的结果。

    而以多线程模式运行时,并不会立即显示结果。因为我们希望让 MyThread 类越通用越好 (有输出和没有输出的调用都能够执行),我们要一直等到所有线程都执行结束,然后调用 getResult() 方法来最终显示每个函数的返回值。

    你会发现在每个函数中都加入了 sleep() 调用,用于减慢执行速度,以便让我们看到多线程是如何改善性能的。在实际工作中,如果确实有不同的执行时间,你肯定不会在其中调用 sleep() 函数。

    References

    Python 核心编程 (第 3 版)

    展开全文
  • java单线程和多线程的实现方式java单线程实现方式1、创建单线程java多线程的实现方式创建线程池2、停止线程 java单线程实现方式 1、创建单线程 /** * 单个线程管理 */ ExecutorService singleThreadExecutor = ...

    java单线程实现方式

    1、创建单线程

        /**
         * 单个线程管理
         */
        ExecutorService singleThreadExecutor = newFixedThreadPool(1);
    
        /**
         * 创建线程
         * @param nThreads
         * @return
         */
        public ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
        }
    
    

    java多线程的实现方式

    创建线程池

       /**
         * 创建线程池
         *
         * @return
         */
        public static ScheduledExecutorService getmScheduledExecutorService() {
            if (mScheduledExecutorService == null) {
                synchronized (ScheduledExecutorServiceManager.class) {
                    if (mScheduledExecutorService == null) {
                        mScheduledExecutorService = new ScheduledThreadPoolExecutor(10);
                    }
                }
            }
            return mScheduledExecutorService;
        }
    

    2、停止线程

        /**
         * 停止线程
         */
        public static void stopScheduledExecutorService() {
            if (mScheduledExecutorService == null) {
                return;
            }
            try {
                if (mScheduledExecutorService != null) {
                    mScheduledExecutorService.shutdown();
                }
                if (!mScheduledExecutorService.awaitTermination(1, TimeUnit.SECONDS)) {
                    if (mScheduledExecutorService != null) {
                        mScheduledExecutorService.shutdownNow();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                if (mScheduledExecutorService != null) {
                    mScheduledExecutorService.shutdownNow();
                }
            } finally {
                mScheduledExecutorService = null;
            }
        }
    
    }
    
    展开全文
  • 单线程和多线程的优缺点

    千次阅读 2018-08-23 12:58:55
    单线程和多线程的优缺点   单线程和多线程的优缺点 多线程处理的优点 同步应用程序的开发比较容易,但由于需要在上一个任务完成后才能开始新的任务,所以其效率通常比多线程应用程序低。如果完成同步任务所用的...
  • 分别使用单线程和多线程把一个文件夹下的饿一百张图片复制到另一个文件夹下,比较它们的处理时间 使用单线程: package lesson19; import java.io.File; import java.io.FileInputStream; import java.io....
  • 快速理解Java单线程和多线程比较

    千次阅读 2019-07-10 16:43:00
    单线程是一个一个线程顺序执行,一个线程只有当前一个线程执行完之后才能执行。这种方法可以会导致当某个线程等待响应的时间特别长时,下一个线程...所以当比较单线程和多线程哪个更快时,就是对上面两者之间开销的...
  • 什么是进程? 当一个程序开始运行时,它就是一个进程,进程包括运行中的程序程序所使用到的内存系统资源。...多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务, 也...
  • 线程的执行时无序的,是由操作系统决定的 单线程:默认情况下,程序启动只有一个线程,这个线程就是主线程 注意点:target后面的赋值不需要括号() 多线程:借助包 import threading ...
  • 四、多线程单线程的区别 五、主线程与子线程之间的关系 在软件层面,多线程就是能同时从多个路线同时执行处理。从软件的角度来说,线程可以看作是同时的。即便在单核处理器的电脑上也能实现多线程。但是多个线程...
  • python 单线程和多线程

    千次阅读 2017-02-27 16:50:14
    单线程, 在好些年前的MS-DOS时代,操作系统处理问题都是单任务的,我想做听音乐看电影两件事儿,那么一定要先排一下顺序。#coding=utf-8 import threading from time import ctime,sleepdef music(func): for i ...
  • 今晚和一同事在车上闲聊起了关于linux下的多线程和单线程问题,最后总结后得到一个问题:在软实时的linux操作系统下(cpu单核和多核分两种情况说),对消息的处理,是采用多线程程序处理快呢...单线程和多线程的优缺点
  • java中单线程和多线程

    千次阅读 2017-04-25 11:49:19
    实现并启动线程有两种方法1、写一个类继承自Thread类,重写run方法。用start方法启动线程2、写一个类实现Runnable接口,实现run方法。用new Thread(Runnable target).start()方法来启动1.火车票的例子继承Thread...
  • Spring Boot 定时任务单线程和多线程

    万次阅读 多人点赞 2018-03-01 14:46:21
    第二种定时任务:单线程和多线程 1、创建定时任务: package com.accord.task; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.annotation.Scheduled; ...
  • python之单线程和多线程访问网站

    千次阅读 2018-04-16 16:20:14
    在了解多线程的时候我们需要先了解单线程问题。我对单线程做一简单的分析。 1、单线程问题 ——单线程就是我们最原始的方法,直接写出访问网站的脚本不需要任何多线程处理例如我们要访问300个网站,网站下载...
  • Java单线程和多线程详解

    千次阅读 2016-07-31 13:06:31
    单线程 package com; public class SingletonThread { public static void main(String[] args) { // TODO Auto-generated method stub Thread thread = Thread.currentThread(); thread.setName("单线程...
  • 之前一直混淆同步和单线程之间的概念今就这几个概念谈一下自己的理解 1、同步(Sync) 先说一下概念:所谓同步,就是发出一个功能调用时,在没有得到结果之前,该调用就不返回或继续执行后续操作。 我理解是:...
  • 进程 : 操作系统分配资源的最小单元 ; 线程 : 是操作系统调度的最小单元;...(但是当同一段代码在同一时间有多个请求访问,这就涉及线程安全的问题啦,也就是说的线程安全,多线程编程啦) 这里要说一句题外话...
  • java单线程和多线程的区别

    千次阅读 2015-08-16 22:15:56
    java单线程
  • 同步就是一个任务是连续完成的,...单线程就是在同一个时间点,只能干一件事,多线程表示可以同时干多件事。 串行并行这个概念是数据传输的两种方式,串行传输表示数据是一位接一位的传送;并行传输则是一次传输多...
  • @Scheduled定时任务单线程和多线程

    千次阅读 2019-02-28 19:02:15
    1)@Scheduled 单个方法内部单线程执行,不会存在前一个定时任务没完成,开启后一个定时任务的情况 例如:方法a,a的第一遍执行中途卡主了,即使a的定时时间到了a也不会再次执行,串行 2)@Scheduled 2.1)默认...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,108
精华内容 11,643
关键字:

单线程和多线程