精华内容
下载资源
问答
  • 2021-01-14 03:20:29

    其实关于爬虫并没有明确多少数量开线程,因为这个是无穷的,随着时代的不断发展,每一个革新都给我们焕然一新的感觉,可能大家现在在学习的时候,已知内容是有限的,真正在不断探索以后,会发现这个内容是无穷了,小编就看到一组代码可以爬取几百万的线程数据,一起来看下吧~

    1、爬虫环境

    Pycharm python3.7.0

    2、进程和线程的关系:

    一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。

    资源分配给进程,同一进程的所有线程共享该进程的所有资源。

    CPU 分给线程,即真正在 CPU 上运行的是线程。

    3、多线程通信实例

    因为全局变量并不是线程安全的,比如说全局变量里(列表类型)只有一个 url 了,线程 B 判断了一下全局变量非空,在还没有取出该 url 之前,cpu 把时间片给了线程 C,线程 C 将最后一个url 取走了,这时 cpu 时间片又轮到了 B,B 就会因为在一个空的列表里取数据而报错,而 queue 模块实现了多生产者、多消费者队列,在放值取值时是线程安全的。

    4、实例代码import threading # 导入 threading 模块

    from queue import Queue #导入 queue 模块

    import time #导入 time 模块

    # 爬取文章详情页

    def get_detail_html(detail_url_list, id):

    while True:

    url = detail_url_list.get() #Queue 队列的 get 方法用于从队列中提取元素

    time.sleep(2) # 延时 2s,模拟网络请求和爬取文章详情的过程

    print("thread {id}: get {url} detail finished".format(id=id,url=url)) #打印线程 id 和被爬取了文章内容的 url

    # 爬取文章列表页

    def get_detail_url(queue):

    for i in range(10000):

    time.sleep(1) # 延时 1s,模拟比爬取文章详情要快

    queue.put("http://testedu.com/{id}".format(id=i))#Queue 队列的 put 方法用于向 Queue 队列中放置元素,由于 Queue 是先进先出队列,所以先被 Put 的 URL 也就会被先 get 出来。

    print("get detail url {id} end".format(id=i))#打印出得到了哪些文章的 url

    #主函数

    if __name__ == "__main__":

    detail_url_queue = Queue(maxsize=1000) #用 Queue 构造一个大小为 1000 的线程安全的先进先出队列

    # 先创造四个线程

    thread = threading.Thread(target=get_detail_url, args=(detail_url_queue,)) #A 线程负责抓取列表

    url

    html_thread= []

    for i in range(3):

    thread2 = threading.Thread(target=get_detail_html, args=(detail_url_queue,i))

    html_thread.append(thread2)#B C D 线程抓取文章详情

    start_time = time.time()

    # 启动四个线程

    thread.start()

    for i in range(3):

    html_thread[i].start()

    # 等待所有线程结束,thread.join()函数代表子线程完成之前,其父进程一直处于阻塞状态。

    thread.join()

    for i in range(3):

    html_thread[i].join()

    print("last time: {} s".format(time.time()-start_time))

    #等 ABCD 四个线程都结束后,在主进程中计算总爬取时间。

    好了,以上就是关于python爬虫里的进程内容了,大家可以去了解下哦~python的内容都是无穷尽的,大家也可以开拓创新,去找到知识的彼岸。

    更多相关内容
  • OC开线程的三种方式

    千次阅读 2018-01-25 09:19:49
    第一种NSThread   //NSThread 方法1 需要手动start];  NSThread *thread=[[NSThread alloc]initWithTarget:self selector:@selector(threadRun:) ... thread.name =@"线程1";  //优先级 0.0-1.0 默认0
    第一种NSThread 


       //NSThread 方法1 需要手动start];
        NSThread *thread=[[NSThread alloc]initWithTarget:self selector:@selector(threadRun:) object:@"参数"];
       thread.name =@"线程1";
        //优先级 0.0-1.0 默认0.5 0.0最低1.0最高
        thread.threadPriority=0.6;




      [thread start];
        
        //NSThread 方法2
        [NSThread detachNewThreadSelector:@selector(threadRun:) toTarget:self withObject:@"参数"];
          //NSThread 方法3
        [self performSelectorInBackground:@selector(threadRun:) withObject:@"参数"];
        
    }


    //多个参数可以用数组或者字典
    -(void)threadRun:(NSString *)param{
        
          //回到主线程
        [self  performSelectorOnMainThread:@selector(update) withObject:nil waitUntilDone:YES];
    }


    第二种 GCD
    -(void)gcdThread{
        
        /**第一种自己创建队列
         第一个参数:C语言的字符串,标签随便填
         第二个参数 队列的类型。
         DISPATCH_QUEUE_CONCURRENT并发 //开多条线程
         DISPATCH_QUEUE_SERIAL 串行 只开一条线程
         */
    //    dispatch_queue_t queue= dispatch_queue_create("com.ecsino.homplus",DISPATCH_QUEUE_CONCURRENT);
        /**
         第二种拿系统的队列
         第一个参数 优先级
         第二个参数 预留给未来使用 随便填0
         */
        dispatch_queue_t queue=  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        
        dispatch_async(queue, ^{
           //线程内
            
            dispatch_async(dispatch_get_main_queue(), ^{
               //回到主线程
            });
            
        });
        
    }


    /**
     
     gcd栅栏函数
     会先执行栅栏函数前面的异步任务
     然后执行栅栏函数
     再执行栅栏函数下面的异步任务
     */
    -(void)barrier{
        
        /**这里的队列必须用dispatch_queue_create创建的
         不能用系统的dispatch_get_global_queue
         否则不会生效*/
        dispatch_barrier_async(dispatch_queue_create("com.ecsino.homplus",DISPATCH_QUEUE_CONCURRENT), ^{
            
        });
        
    }
    /**gcd队列组
     可以添加完成任务通知功能
     用于任务监听
     */
    -(void)group{
        //创建队列
        dispatch_queue_t queue=dispatch_get_global_queue(0, 0);
        // 创建队列组
        dispatch_group_t group=dispatch_group_create();
        //异步函数
        dispatch_group_async(group, queue, ^{
            NSLog(@"异步一");
        });
        dispatch_group_async(group, queue, ^{
            NSLog(@"异步二");
        });
        dispatch_group_async(group, queue, ^{
            NSLog(@"异步三");
        });
        


        //异步等
        dispatch_group_notify(group, queue, ^{
              NSLog(@"全部任务完成通知");
        });
        //死等 任务不完成 后面代码不执行
        // dispatch_group_wait(group, DISPATCH_TIME_FOREVER);


    }
    /**gcd快速迭代*/
    -(void)apply{
        
        /**
         快速迭代
         第一个参数遍历的参数
         第二个参数队列必须是并发队列
         第三个参数 遍历的索引*/
        dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index) {
            
        });
        
    }
    /*
     第三种 线程
    NSoperation
     */
    -(void)operation{
        
        //第一种方式
    //    NSInvocationOperation *operation=[[NSInvocationOperation alloc]initWithTarget:self selector:@selector(startOperaion) object:nil];
       //第二种方式
        NSBlockOperation *operation=[NSBlockOperation blockOperationWithBlock:^{
             //执行线程任务
            NSURL *url=[NSURL URLWithString:@"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1516809008589&di=f037ce52a7884e59ab83f0420e94a3c4&imgtype=0&src=http%3A%2F%2Fmvimg4.meitudata.com%2F5604ee3a30f7e560.jpg 


    "];
           NSData *imageData= [NSData dataWithContentsOfURL:url];
           _image= [UIImage imageWithData:imageData];
           
        }];
        
        NSBlockOperation *operation1=[NSBlockOperation blockOperationWithBlock:^{
            //执行线程任务
        }];
        NSBlockOperation *operation2=[NSBlockOperation blockOperationWithBlock:^{
            //执行线程任务
        }];
        
        [operation addExecutionBlock:^{
            //可以追加任务
        }];
        operation.completionBlock = ^{
            //  完成监听
            [[NSOperationQueue mainQueue]addOperationWithBlock:^{
                //主线程更新任务
                if(_image){
                   // NSLog(@"主线程更新任务");
                     [_iv setImage:_image];
                }
               
            }];
        };
        
        //如果2添加依赖1 那么执行完1才会执行2
        [operation2 addDependency:operation1];
        //如果operation1添加依赖operation 那么执行完operation才会执行operation1
        [operation1 addDependency:operation];
        NSOperationQueue *queue=[[NSOperationQueue alloc]init];
        //设置最大并发数
       //   queue.maxConcurrentOperationCount=3;
        [queue addOperation:operation];
          [queue addOperation:operation1];
          [queue addOperation:operation2];


      // [queue setSuspended:YES];//暂停 NO可以恢复 不能暂停正在执行状态的任务
       // [queue cancelAllOperations];//取消 不可以恢复
    //
    //    //简便方法
    //    [queue addOperationWithBlock:^{
    //        //线程任务;
    //    }];
        
        
    }

    展开全文
  • JVM内存区域,开线程影响哪块内存

    千次阅读 2019-07-19 22:57:49
    概括地说来:JVM初始运行的时候都会分配好Method Area(方法区)和Heap(堆),而JVM 每遇到一个线程,就为其分配一个Program Counter Register(程序计数器), VM Stack(虚拟机栈)和Native Method Stack (本地...

    JVM运行时数据区

    概括地说来:JVM初始运行的时候都会分配好Method Area(方法区)Heap(堆),而JVM 每遇到一个线程,就为其分配一个Program Counter Register(程序计数器), VM Stack(虚拟机栈)Native Method Stack (本地方法栈),当线程终止时,三者(虚拟机栈,本地方法栈和程序计数器)所占用的内存空间也会被释放掉。

    每当有线程被创建的时候,JVM就需要为其在内存中分配虚拟机栈和本地方法栈来记录调用方法的内容,分配程序计数器记录指令执行的位置,这样的内存消耗就是创建线程的内存代价。

    内存作为有限的资源,如果JVM创建了过多的线程,必然会导致资源的耗尽。因此,使用Executor架构复用线程可以节省内存资源,是十分必要的。

    JVM的并发是通过线程切换并分配时间片执行来实现的。 在任何一个时刻, 一个处理器内核只会执行一条线程中的指令。因此, 为了线程切换后能恢复到正确的执行位置, JVM需要先保存被挂起线程的上下文环境:将线程执行位置保存到程序计数器中,将调用方法的信息保存在栈中;同时将待执行线程的程序计数器和栈中的信息写入到处理器中,完成线程的上下文切换。维护线程隔离数据区中的内容在处理器中的导入导出,就是线程切换的性能代价。


    对象的创建——静态区域加载的多线程安全性

    为了保证多线程安全性,一些必要的操作都需要加锁来保证其原子性和可见性,但是类中静态区的代码是不需要加锁就能保证多线程安全性。这是因为什么呢?

    答案在于JVM类加载过程的保护机制。和普通类的实例被分配在Java堆上不同,类的静态属性都保存在方法区,其创建收到类加载过程的影响。

    类的加载过程大题分为:加载(Loading),连接(Linking),初始化(Initialization)使用(Using)和卸载(UnLoading)五个步骤。

    这里和静态属性有关的主要是连接和初始化:

    在连接步骤的准备阶段,静态属性会分配内存;在初始化步骤,JVM会生成一个特别的方法——<clinit>方法来专门执行静态代码块和静态变量初始化。

    <clinit>方法执行的过程中,JVM会对类加锁,保证在多线程环境下,只有一个线程能成功执行<clinit>方法,其他线程都将被拥塞,并且<clinit>方法只能被执行一次,被拥塞的线程被唤醒之后也不会再去执行<clinit>方法。如果类有继承关系,JVM还会保证父类的<clinit>方法将先于子类的<clinit>方法执行。

    由此可见,静态代码块的多线程安全性是由JVM为其加锁实现的,这也是延迟初始化占位类模式的安全性基础。

    展开全文
  • Java多线程超详解

    万次阅读 多人点赞 2019-06-11 01:00:30
    随着计算机的配置越来越高,我们需要将进程进一步优化,细分为线程,充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说,今天本帅将记录自己线程的学习。 线程的相关API //获取当前...

    引言

    随着计算机的配置越来越高,我们需要将进程进一步优化,细分为线程,充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。
    那么话不多说,今天本帅将记录自己线程的学习。

    程序,进程,线程的基本概念+并行与并发:

    程序:是为完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码,静态对象。
    进程:是程序的一次执行过程,或是正在运行的一个程序,是一个动态的过程,有它自身的产生,存在和消亡的过程。-------生命周期
    线程:进程可进一步细化为线程,是一个程序内部的一条执行路径

    即:线程《线程(一个程序可以有多个线程)
    程序:静态的代码 进程:动态执行的程序
    线程:进程中要同时干几件事时,每一件事的执行路径成为线程。

    并行:多个CPU同时执行多个任务,比如:多个人同时做不同的事
    并发:一个CPU(采用时间片)同时执行多个任务,比如秒杀平台,多个人做同件事

    线程的相关API

    //获取当前线程的名字
    Thread.currentThread().getName()

    1.start():1.启动当前线程2.调用线程中的run方法
    2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
    3.currentThread():静态方法,返回执行当前代码的线程
    4.getName():获取当前线程的名字
    5.setName():设置当前线程的名字
    6.yield():主动释放当前线程的执行权
    7.join():在线程中插入执行另一个线程,该线程被阻塞,直到插入执行的线程完全执行完毕以后,该线程才继续执行下去
    8.stop():过时方法。当执行此方法时,强制结束当前线程。
    9.sleep(long millitime):线程休眠一段时间
    10.isAlive():判断当前线程是否存活

    判断是否是多线程

    一条线程即为一条执行路径,即当能用一条路径画出来时即为一个线程
    例:如下看似既执行了方法一,又执行了方法2,但是其实质就是主线程在执行方法2和方法1这一条路径,所以就是一个线程

    public class Sample{
    		public void method1(String str){
    			System.out.println(str);
    		}
    	
    	public void method2(String str){
    		method1(str);
    	}
    	
    	public static void main(String[] args){
    		Sample s = new Sample();
    		s.method2("hello");
    	}
    }
    

    在这里插入图片描述

    线程的调度

    调度策略:
    时间片:线程的调度采用时间片轮转的方式
    抢占式:高优先级的线程抢占CPU
    Java的调度方法:
    1.对于同优先级的线程组成先进先出队列(先到先服务),使用时间片策略
    2.对高优先级,使用优先调度的抢占式策略

    线程的优先级

    等级:
    MAX_PRIORITY:10
    MIN_PRIORITY:1
    NORM_PRIORITY:5

    方法:
    getPriority():返回线程优先级
    setPriority(int newPriority):改变线程的优先级

    注意!:高优先级的线程要抢占低优先级的线程的cpu的执行权。但是仅是从概率上来说的,高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完以后,低优先级的线程才执行。

    多线程的创建方式

    1. 方式1:继承于Thread类

    1.创建一个集成于Thread类的子类 (通过ctrl+o(override)输入run查找run方法)
    2.重写Thread类的run()方法
    3.创建Thread子类的对象
    4.通过此对象调用start()方法

    start与run方法的区别:

    start方法的作用:1.启动当前线程 2.调用当前线程的重写的run方法(在主线程中生成子线程,有两条线程)
    调用start方法以后,一条路径代表一个线程,同时执行两线程时,因为时间片的轮换,所以执行过程随机分配,且一个线程对象只能调用一次start方法。
    run方法的作用:在主线程中调用以后,直接在主线程一条线程中执行了该线程中run的方法。(调用线程中的run方法,只调用run方法,并不新开线程)

    总结:我们不能通过run方法来新开一个线程,只能调用线程中重写的run方法(可以在线程中不断的调用run方法,但是不能开启子线程,即不能同时干几件事),start是开启线程,再调用方法(即默认开启一次线程,调用一次run方法,可以同时执行几件事)
    在这里插入图片描述

    多线程例子(火车站多窗口卖票问题)

    	package com.example.paoduantui.Thread;
    	
    	import android.view.Window;
    	
    	/**
    	 *
    	 * 创建三个窗口卖票,总票数为100张,使用继承自Thread方式
    	 * 用静态变量保证三个线程的数据独一份
    	 * 
    	 * 存在线程的安全问题,有待解决
    	 *
    	 * */
    	
    	public class ThreadDemo extends Thread{
    	
    	    public static void main(String[] args){
    	        window t1 = new window();
    	        window t2 = new window();
    	        window t3 = new window();
    	
    	        t1.setName("售票口1");
    	        t2.setName("售票口2");
    	        t3.setName("售票口3");
    	
    	        t1.start();
    	        t2.start();
    	        t3.start();
    	    }
    	
    	}
    	
    	class window extends Thread{
    	    private static int ticket = 100; //将其加载在类的静态区,所有线程共享该静态变量
    	
    	    @Override
    	    public void run() {
    	        while(true){
    	            if(ticket>0){
    	//                try {
    	//                    sleep(100);
    	//                } catch (InterruptedException e) {
    	//                    e.printStackTrace();
    	//                }
    	                System.out.println(getName()+"当前售出第"+ticket+"张票");
    	                ticket--;
    	            }else{
    	                break;
    	            }
    	        }
    	    }
    	}
    

    2. 方式2:实现Runable接口方式

    1.创建一个实现了Runable接口的类
    2.实现类去实现Runnable中的抽象方法:run()
    3.创建实现类的对象
    4.将此对象作为参数传递到Thread类中的构造器中,创建Thread类的对象
    5.通过Thread类的对象调用start()

    具体操作,将一个类实现Runable接口,(插上接口一端)。
    另外一端,通过实现类的对象与线程对象通过此Runable接口插上接口实现

    	package com.example.paoduantui.Thread;
    	
    	public class ThreadDemo01 {
    	    
    	    public static  void main(String[] args){
    	        window1 w = new window1();
    	        
    	        //虽然有三个线程,但是只有一个窗口类实现的Runnable方法,由于三个线程共用一个window对象,所以自动共用100张票
    	        
    	        Thread t1=new Thread(w);
    	        Thread t2=new Thread(w);
    	        Thread t3=new Thread(w);
    	
    	        t1.setName("窗口1");
    	        t2.setName("窗口2");
    	        t3.setName("窗口3");
    	        
    	        t1.start();
    	        t2.start();
    	        t3.start();
    	    }
    	}
    	
    	class window1 implements Runnable{
    	    
    	    private int ticket = 100;
    	
    	    @Override
    	    public void run() {
    	        while(true){
    	            if(ticket>0){
    	//                try {
    	//                    sleep(100);
    	//                } catch (InterruptedException e) {
    	//                    e.printStackTrace();
    	//                }
    	                System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");
    	                ticket--;
    	            }else{
    	                break;
    	            }
    	        }
    	    }
    	}
    

    比较创建线程的两种方式:
    开发中,优先选择实现Runable接口的方式
    原因1:实现的方式没有类的单继承性的局限性
    2:实现的方式更适合用来处理多个线程有共享数据的情况
    联系:Thread也是实现自Runable,两种方式都需要重写run()方法,将线程要执行的逻辑声明在run中

    3.新增的两种创建多线程方式

    1.实现callable接口方式:

    与使用runnable方式相比,callable功能更强大些:
    runnable重写的run方法不如callaalbe的call方法强大,call方法可以有返回值
    方法可以抛出异常
    支持泛型的返回值
    需要借助FutureTask类,比如获取返回结果

    package com.example.paoduantui.Thread;
    
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * 创建线程的方式三:实现callable接口。---JDK 5.0新增
     *是否多线程?否,就一个线程
     *
     * 比runable多一个FutureTask类,用来接收call方法的返回值。
     * 适用于需要从线程中接收返回值的形式
     * 
     * //callable实现新建线程的步骤:
     * 1.创建一个实现callable的实现类
     * 2.实现call方法,将此线程需要执行的操作声明在call()中
     * 3.创建callable实现类的对象
     * 4.将callable接口实现类的对象作为传递到FutureTask的构造器中,创建FutureTask的对象
     * 5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start方法启动(通过FutureTask的对象调用方法get获取线程中的call的返回值)
     * 
     * */
    
    
    //实现callable接口的call方法
    class NumThread implements Callable{
    
        private int sum=0;//
    
        //可以抛出异常
        @Override
        public Object call() throws Exception {
            for(int i = 0;i<=100;i++){
                if(i % 2 == 0){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                    sum += i;
                }
            }
            return sum;
        }
    }
    
    public class ThreadNew {
    
        public static void main(String[] args){
            //new一个实现callable接口的对象
            NumThread numThread = new NumThread();
    
            //通过futureTask对象的get方法来接收futureTask的值
            FutureTask futureTask = new FutureTask(numThread);
    
            Thread t1 = new Thread(futureTask);
            t1.setName("线程1");
            t1.start();
    
            try {
                //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
               Object sum = futureTask.get();
               System.out.println(Thread.currentThread().getName()+":"+sum);
            } catch (ExecutionException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    使用线程池的方式:

    背景:经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
    思路:提前创建好多个线程,放入线程池之,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。类似生活中的公共交通工具。(数据库连接池)
    好处:提高响应速度(减少了创建新线程的时间)
    降低资源消耗(重复利用线程池中线程,不需要每次都创建)
    便于线程管理
    corePoolSize:核心池的大小
    maximumPoolSize:最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止
    。。。。。。

    JDK 5.0 起提供了线程池相关API:ExecutorService 和 Executors
    ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor.
    void execute(Runnable coommand):执行任务/命令,没有返回值,一般用来执行Runnable
    Futuresubmit(Callable task):执行任务,有返回值,一般又来执行Callable
    void shutdown():关闭连接池。

    Executors工具类,线程池的工厂类,用于创建并返回不同类型的线程池
    Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池
    Executors.newFixedThreadPool(n)创建一个可重用固定线程数的线程池
    Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
    Executors.newScheduledThreadPool(n)创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

    线程池构造批量线程代码如下:

    package com.example.paoduantui.Thread;
    
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 创建线程的方式四:使用线程池(批量使用线程)
     *1.需要创建实现runnable或者callable接口方式的对象
     * 2.创建executorservice线程池
     * 3.将创建好的实现了runnable接口类的对象放入executorService对象的execute方法中执行。
     * 4.关闭线程池
     *
     * */
    
    class NumberThread implements Runnable{
    
    
        @Override
        public void run() {
            for(int i = 0;i<=100;i++){
                if (i % 2 ==0 )
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    
    class NumberThread1 implements Runnable{
        @Override
        public void run() {
            for(int i = 0;i<100; i++){
                if(i%2==1){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }
    }
    
    public class ThreadPool {
    
        public static void main(String[] args){
    
            //创建固定线程个数为十个的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
    
            //new一个Runnable接口的对象
            NumberThread number = new NumberThread();
            NumberThread1 number1 = new NumberThread1();
    
            //执行线程,最多十个
            executorService.execute(number1);
            executorService.execute(number);//适合适用于Runnable
    
            //executorService.submit();//适合使用于Callable
            //关闭线程池
            executorService.shutdown();
        }
    
    }
    

    目前两种方式要想调用新线程,都需要用到Thread中的start方法。

    java virtual machine(JVM):java虚拟机内存结构

    程序(一段静态的代码)——————》加载到内存中——————》进程(加载到内存中的代码,动态的程序)
    进程可细分为多个线程,一个线程代表一个程序内部的一条执行路径
    每个线程有其独立的程序计数器(PC,指导着程序向下执行)与运行栈(本地变量等,本地方法等)
    在这里插入图片描述

    大佬传送门:https://blog.csdn.net/bluetjs/article/details/52874852

    线程通信方法:

    wait()/ notify()/ notifayAll():此三个方法定义在Object类中的,因为这三个方法需要用到锁,而锁是任意对象都能充当的,所以这三个方法定义在Object类中。

    由于wait,notify,以及notifyAll都涉及到与锁相关的操作
    wait(在进入锁住的区域以后阻塞等待,释放锁让别的线程先进来操作)---- Obj.wait 进入Obj这个锁住的区域的线程把锁交出来原地等待通知
    notify(由于有很多锁住的区域,所以需要将区域用锁来标识,也涉及到锁) ----- Obj.notify 新线程进入Obj这个区域进行操作并唤醒wait的线程

    有点类似于我要拉粑粑,我先进了厕所关了门,但是发现厕所有牌子写着不能用,于是我把厕所锁给了别人,别人进来拉粑粑还是修厕所不得而知,直到有人通知我厕所好了我再接着用。

    所以wait,notify需要使用在有锁的地方,也就是需要用synchronize关键字来标识的区域,即使用在同步代码块或者同步方法中,且为了保证wait和notify的区域是同一个锁住的区域,需要用锁来标识,也就是锁要相同的对象来充当

    线程的分类:

    java中的线程分为两类:1.守护线程(如垃圾回收线程,异常处理线程),2.用户线程(如主线程)

    若JVM中都是守护线程,当前JVM将退出。(形象理解,唇亡齿寒)

    线程的生命周期:

    JDK中用Thread.State类定义了线程的几种状态,如下:

    线程生命周期的阶段描述
    新建当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
    就绪处于新建状态的线程被start后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件,只是没分配到CPU资源
    运行当就绪的线程被调度并获得CPU资源时,便进入运行状态,run方法定义了线程的操作和功能
    阻塞在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU并临时终止自己的执行,进入阻塞状态
    死亡线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

    在这里插入图片描述

    线程的同步:在同步代码块中,只能存在一个线程。

    线程的安全问题:

    什么是线程安全问题呢?
    线程安全问题是指,多个线程对同一个共享数据进行操作时,线程没来得及更新共享数据,从而导致另外线程没得到最新的数据,从而产生线程安全问题。

    上述例子中:创建三个窗口卖票,总票数为100张票
    1.卖票过程中,出现了重票(票被反复的卖出,ticket未被减少时就打印出了)错票。
    2.问题出现的原因:当某个线程操作车票的过程中,尚未完成操作时,其他线程参与进来,也来操作车票。(将此过程的代码看作一个区域,当有线程进去时,装锁,不让别的线程进去)
    生动理解的例子:有一个厕所,有人进去了,但是没有上锁,于是别人不知道你进去了,别人也进去了对厕所也使用造成错误。
    3.如何解决:当一个线程在操作ticket时,其他线程不能参与进来,直到此线程的生命周期结束
    4.在java中,我们通过同步机制,来解决线程的安全问题。

    方式一:同步代码块
    使用同步监视器(锁)
    Synchronized(同步监视器){
    //需要被同步的代码
    }
    说明:

    1. 操作共享数据的代码(所有线程共享的数据的操作的代码)(视作卫生间区域(所有人共享的厕所)),即为需要共享的代码(同步代码块,在同步代码块中,相当于是一个单线程,效率低)
    2. 共享数据:多个线程共同操作的数据,比如公共厕所就类比共享数据
    3. 同步监视器(俗称:锁):任何一个的对象都可以充当锁。(但是为了可读性一般设置英文成lock)当锁住以后只能有一个线程能进去(要求:多个线程必须要共用同一把锁,比如火车上的厕所,同一个标志表示有人)

    Runable天生共享锁,而Thread中需要用static对象或者this关键字或者当前类(window。class)来充当唯一锁

    方式二:同步方法
    使用同步方法,对方法进行synchronized关键字修饰
    将同步代码块提取出来成为一个方法,用synchronized关键字修饰此方法。
    对于runnable接口实现多线程,只需要将同步方法用synchronized修饰
    而对于继承自Thread方式,需要将同步方法用static和synchronized修饰,因为对象不唯一(锁不唯一)

    总结:1.同步方法仍然涉及到同步监视器,只是不需要我们显示的声明。
    2.非静态的同步方法,同步监视器是this
    静态的同步方法,同步监视器是当前类本身。继承自Thread。class

    方式三:JDK5.0新增的lock锁方法

    package com.example.paoduantui.Thread;
    
    
    import java.util.concurrent.locks.ReentrantLock;
    
    class Window implements Runnable{
        private int ticket = 100;//定义一百张票
        //1.实例化锁
        private ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
            
                while (true) {
    
                    //2.调用锁定方法lock
                    lock.lock();
    
                    if (ticket > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "售出第" + ticket + "张票");
                        ticket--;
                    } else {
                        break;
                    }
                }
    
    
            }
    }
    
    public class LockTest {
    
        public static void main(String[] args){
           Window w= new Window();
    
           Thread t1 = new Thread(w);
           Thread t2 = new Thread(w);
           Thread t3 = new Thread(w);
    
           t1.setName("窗口1");
           t2.setName("窗口1");
           t3.setName("窗口1");
    
           t1.start();
           t2.start();
           t3.start();
        }
    
    }
    

    总结:Synchronized与lock的异同?

    相同:二者都可以解决线程安全问题
    不同:synchronized机制在执行完相应的代码逻辑以后,自动的释放同步监视器
    lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())(同时以为着lock的方式更为灵活)

    优先使用顺序:
    LOCK-》同步代码块-》同步方法

    判断线程是否有安全问题,以及如何解决:

    1.先判断是否多线程
    2.再判断是否有共享数据
    3.是否并发的对共享数据进行操作
    4.选择上述三种方法解决线程安全问题

    例题:

    	package com.example.paoduantui.Thread;
    	
    	/***
    	 * 描述:甲乙同时往银行存钱,存够3000
    	 *
    	 *
    	 * */
    	
    	//账户
    	class Account{
    	    private double balance;//余额
    	    //构造器
    	    public Account(double balance) {
    	        this.balance = balance;
    	    }
    	    //存钱方法
    	    public synchronized void deposit(double amt){
    	        if(amt>0){
    	            balance +=amt;
    	            try {
    	                Thread.sleep(1000);
    	            } catch (InterruptedException e) {
    	                e.printStackTrace();
    	            }
    	            System.out.println(Thread.currentThread().getName()+"存钱成功,余额为:"+balance);
    	        }
    	    }
    	}
    	
    	//两个顾客线程
    	class Customer extends Thread{
    	     private Account acct;
    	
    	     public Customer(Account acct){
    	         this.acct = acct;
    	     }
    	
    	
    	
    	    @Override
    	    public void run() {
    	        for (int i = 0;i<3;i++){
    	            acct.deposit(1000);
    	        }
    	    }
    	}
    	
    	//主方法,之中new同一个账户,甲乙两个存钱线程。
    	public class AccountTest {
    	
    	    public static void main(String[] args){
    	        Account acct = new Account(0);
    	        Customer c1 = new Customer(acct);
    	        Customer c2 = new Customer(acct);
    	
    	        c1.setName("甲");
    	        c2.setName("乙");
    	
    	        c1.start();
    	        c2.start();
    	    }
    	
    	}
    

    解决单例模式的懒汉式的线程安全问题:

    单例:只能通过静态方法获取一个实例,不能通过构造器来构造实例
    1.构造器的私有化:
    private Bank(){}//可以在构造器中初始化东西
    private static Bank instance = null;//初始化静态实例

    public static Bank getInstance(){
    if(instance!=null){
    instance = new Bank();
    }
    return instance;
    }

    假设有多个线程调用此单例,而调用的获取单例的函数作为操作共享单例的代码块并没有解决线程的安全问题,会导致多个线程都判断实例是否为空,此时就会导致多个实例的产生,也就是单例模式的线程安全问题。

    解决线程安全问题的思路:

    1. 将获取单例的方法改写成同部方法,即加上synchronized关键字,此时同步监视器为当前类本身。(当有多个线程并发的获取实例时,同时只能有一个线程获取实例),解决了单例模式的线程安全问题。
    2. 用同步监视器包裹住同步代码块的方式。

    懒汉式单例模式的模型,例如:生活中的限量版的抢购:
    当一群人并发的抢一个限量版的东西的时候,可能同时抢到了几个人,他们同时进入了房间(同步代码块内)
    但是只有第一个拿到限量版东西的人才能到手,其余人都不能拿到,所以效率稍高的做法是,当东西被拿走时,我们在门外立一块牌子,售罄。
    这样就减少了线程的等待。即下面效率稍高的懒汉式写法:

    package com.example.paoduantui.Thread;
    
    public class Bank {
        //私有化构造器
        private Bank(){}
        //初始化静态实例化对象
        private static  Bank instance = null;
    
        //获取单例实例,此种懒汉式单例模式存在线程不安全问题(从并发考虑)
    
        public static  Bank getInstance(){
            if(instance==null){
                instance = new Bank();
            }
            return  instance;
        }
    
        //同步方法模式的线程安全
        public static synchronized Bank getInstance1(){
            if(instance==null){
                instance = new Bank();
            }
            return  instance;
        }
        //同步代码块模式的线程安全(上锁)
        public  static Bank getInstance2(){
            synchronized (Bank.class){
                if(instance==null){
                    instance = new Bank();
                }
                return  instance;
            }
        }
        
        //效率更高的线程安全的懒汉式单例模式
        /**
         * 由于当高并发调用单例模式的时候,类似于万人夺宝,只有第一个进入房间的人才能拿到宝物,
         * 当多个人进入这个房间时,第一个人拿走了宝物,也就另外几个人需要在同步代码块外等候,
         * 剩下的人只需要看到门口售罄的牌子即已知宝物已经被夺,可以不用进入同步代码块内,提高了效率。
         * 
         * 
         * */
        public static Bank getInstance3(){
            if (instance==null){
                synchronized (Bank.class){
                    if(instance==null){
                        instance = new Bank();
                    }
                }
            }
            return  instance;
        }
    }
    

    线程的死锁问题:

    线程死锁的理解:僵持,谁都不放手,一双筷子,我一只你一只,都等对方放手(死锁,两者都进入阻塞,谁都吃不了饭,进行不了下面吃饭的操作)
    出现死锁以后,不会出现提示,只是所有线程都处于阻塞状态,无法继续

    package com.example.paoduantui.Thread;
    
    
    /**
     * 演示线程的死锁问题
     *
     * */
    public class Demo {
    
        public static void main(String[] args){
    
            final StringBuffer s1 = new StringBuffer();
            final StringBuffer s2 = new StringBuffer();
    
    
            new Thread(){
                @Override
                public void run() {
                    //先拿锁一,再拿锁二
                    synchronized (s1){
                        s1.append("a");
                        s2.append("1");
    
                        synchronized (s2) {
                            s1.append("b");
                            s2.append("2");
    
                            System.out.println(s1);
                            System.out.println(s2);
                        }
                    }
                }
            }.start();
    
            //使用匿名内部类实现runnable接口的方式实现线程的创建
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (s2){
                        s1.append("c");
                        s2.append("3");
    
                        synchronized (s1) {
                            s1.append("d");
                            s2.append("4");
    
                            System.out.println(s1);
                            System.out.println(s2);
                        }
                    }
                }
            }).start();
        }
    
    }
    

    运行结果:
    1.先调用上面的线程,再调用下面的线程:
    在这里插入图片描述
    2.出现死锁:
    在这里插入图片描述
    3.先调用下面的线程,再调用上面的线程。
    在这里插入图片描述

    死锁的解决办法:

    1.减少同步共享变量
    2.采用专门的算法,多个线程之间规定先后执行的顺序,规避死锁问题
    3.减少锁的嵌套。

    线程的通信

    通信常用方法:

    通信方法描述
    wait()一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
    notify一旦执行此方法,就会唤醒被wait的一个线程,如果有多个线程,就唤醒优先级高的线程
    notifyAll一旦执行此方法,就会唤醒所有被wait()的线程

    使用前提:这三个方法均只能使用在同步代码块或者同步方法中。

    package com.example.paoduantui.Thread;
    
    
    /**
     * 线程通信的例子:使用两个线程打印1—100,线程1,线程2交替打印
     *
     * 当我们不采取线程之间的通信时,无法达到线程1,2交替打印(cpu的控制权,是自动分配的)
     * 若想达到线程1,2交替打印,需要:
     * 1.当线程1获取锁以后,进入代码块里将number++(数字打印并增加)操作完以后,为了保证下个锁为线程2所有,需要将线程1阻塞(线程1你等等wait())。(输出1,number为2)
     * 2.当线程2获取锁以后,此时线程1已经不能进入同步代码块中了,所以,为了让线程1继续抢占下一把锁,需要让线程1的阻塞状态取消(通知线程1不用等了notify()及notifyAll()),即应该在进入同步代码块时取消线程1的阻塞。
     *
     * */
    
    class Number implements Runnable{
    
        private int number = 1;//设置共享数据(线程之间对于共享数据的共享即为通信)
    
    
        //对共享数据进行操作的代码块,需要线程安全
        @Override
        public synchronized void run() {
    
            while(true){
                //使得线程交替等待以及通知交替解等待
                notify();//省略了this.notify()关键字
                if(number<100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
    
    public class CommunicationTest {
    
        public static void main(String[] args){
            //创建runnable对象
            Number number = new Number();
    
            //创建线程,并实现runnable接口
            Thread t1 = new Thread(number);
            Thread t2 = new Thread(number);
    
            //给线程设置名字
            t1.setName("线程1");
            t2.setName("线程2");
    
            //开启线程
            t1.start();
            t2.start();
    
        }
    
    }
    

    sleep和wait的异同:

    相同点:一旦执行方法以后,都会使得当前的进程进入阻塞状态
    不同点:
    1.两个方法声明的位置不同,Thread类中声明sleep,Object类中声明wait。
    2.调用的要求不同,sleep可以在任何需要的场景下调用,wait必须使用在同步代码块或者同步方法中
    3.关于是否释放同步监视器,如果两个方法都使用在同步代码块或同步方法中,sleep不会释放,wait会释放

    经典例题:生产者/消费者问题:

    生产者(Priductor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如20个),如果生产者视图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产:如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。

    这里可能出现两个问题:
    生产者比消费者快的时候,消费者会漏掉一些数据没有收到。
    消费者比生产者快时,消费者会去相同的数据。

    package com.example.paoduantui.Thread;
    
    
    /**
     * 线程通信的应用:生产者/消费者问题
     *
     * 1.是否是多线程问题?是的,有生产者线程和消费者线程(多线程的创建,四种方式)
     * 2.多线程问题是否存在共享数据? 存在共享数据----产品(同步方法,同步代码块,lock锁)
     * 3.多线程是否存在线程安全问题? 存在----都对共享数据产品进行了操作。(三种方法)
     * 4.是否存在线程间的通信,是,如果生产多了到20时,需要通知停止生产(wait)。(线程之间的通信问题,需要wait,notify等)
     *
     * */
    
    
    	class Clerk{
    	
    	    private int productCount = 0;
    	
    	
    	    //生产产品
    	    public synchronized void produceProduct() {
    	
    	        if(productCount<20) {
    	            productCount++;
    	
    	            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
    	            notify();
    	        }else{
    	            //当有20个时,等待wait
    	            try {
    	                wait();
    	            } catch (InterruptedException e) {
    	                e.printStackTrace();
    	            }
    	        }
    	    }
    	
    	    //消费产品
    	    public synchronized void consumeProduct() {
    	        if (productCount>0){
    	            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
    	            productCount--;
    	            notify();
    	        }else{
    	            //当0个时等待
    	            try {
    	                wait();
    	            } catch (InterruptedException e) {
    	                e.printStackTrace();
    	            }
    	        }
    	    }
    	}
    	
    	class Producer extends Thread{//生产者线程
    	
    	    private Clerk clerk;
    	
    	    public Producer(Clerk clerk) {
    	        this.clerk = clerk;
    	    }
    	
    	    @Override
    	    public void run() {
    	
    	        try {
    	            sleep(10);
    	        } catch (InterruptedException e) {
    	            e.printStackTrace();
    	        }
    	        System.out.println(Thread.currentThread().getName()+";开始生产产品......");
    	
    	        while(true){
    	            clerk.produceProduct();
    	        }
    	    }
    	}
    	
    	class Consumer implements Runnable{//消费者线程
    	
    	    private Clerk clerk;
    	
    	    public Consumer(Clerk clerk) {
    	        this.clerk = clerk;
    	    }
    	
    	    @Override
    	    public void run() {
    	
    	        System.out.println(Thread.currentThread().getName()+":开始消费产品");
    	
    	        while(true){
    	            try {
    	                Thread.sleep(1);
    	            } catch (InterruptedException e) {
    	                e.printStackTrace();
    	            }
    	
    	            clerk.consumeProduct();
    	        }
    	
    	    }
    	}
    	
    	public class ProductTest {
    	
    	    public static void main(String[] args){
    	        Clerk clerk = new Clerk();
    	
    	        Producer p1 = new Producer(clerk);
    	        p1.setName("生产者1");
    	
    	        Consumer c1 = new Consumer(clerk);
    	        Thread t1 = new Thread(c1);
    	        t1.setName("消费者1");
    	
    	        p1.start();
    	        t1.start();
    	
    	    }
    	
    	}
    
    展开全文
  • python多线程新开线程若有多个参数需要传递的时候,需要用[]来括起来。 threading.Thread(target=one_func, args=[text,path1]) 以上就是两个参数传给one_func
  • fork/join 和开线程数量

    千次阅读 2019-01-18 13:44:31
    //四个线程同时去执行 ForkJoinPool myPool = new ForkJoinPool(4); myPool.submit(() -&gt; {}) 打开的线程数 public class ThreadPoolHelper { public static ThreadPool instance; private ...
  • 一、Python多进程多线程 关于python多进程多线程的相关基础知识,在我之前的博客有写过,并且就关于python多线程的GIL锁问题,也在我的一篇博客中有相关的解释。 为什么python多线程在面对IO密集型任务的时候会产生...
  • Java开启线程的4种方式

    千次阅读 2021-05-25 10:58:46
    本文简要介绍一下线程的4种启动方式, 继承Thread,实现Runnable接口,实现Callable接口,通过线程池来启动线程。以上4种形式的线程启动方式,最终都是通过Thread.start()方法来真正启动线程。 继承Thread 通过...
  • 线程(一):创建线程线程的常用方法

    万次阅读 多人点赞 2018-09-01 19:14:23
    一:为什么要学多线程 应付面试 :多线程几乎是面试中必问的题,所以掌握一定的基础知识是必须的。 了解并发编程:实际工作中很少写多线程的代码,这部分代码一般都被人封装起来了,在业务中使用多线程的机会也...
  • android中直接开线程与使用服务(Service)开线程两种办法都可以执行长时间任务,它们的区别是什么呢?什么时候使用直接开线程,又什么时候启动服务后,再服务中开线程呢?一个service是一个在用户不与你的应用交互时...
  • Qt 中开启线程的五种方式

    千次阅读 2021-09-01 15:37:44
    在开发过程中,使用线程是经常会遇到的场景,本篇文章就来整理一下 Qt 中使用线程的五种方式,方便后期回顾。前面两种比较简单,一笔带过了,主要介绍后面三种。最后两种方法博主最喜欢,不需要继承类,可以直接把...
  • 下面的一段转载自:http://blog.sina.com.cn/s/blog_71dbc27f01017mnj.html下面是快速创建一个新线程的方法:第一种:直接创建子线程并启动 new Thread() {@Overridepublic ... 第二种:先创建子线程,然后启动 ...
  • 在Unity实现Socket通信,当开了一个线程后,如果你没在关闭程序前关闭该线程,会发生你重新运行后unity卡死的现象: 要解决只要关闭线程就好了。 实现:在对象销毁(OnDestroy())前 public void killTreath() ...
  • python多线程详解(超详细)

    万次阅读 多人点赞 2019-09-28 08:33:31
    python中的多线程是一个非常重要的知识点,今天为大家对多线程进行详细的说明,代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python...
  • Java多线程01:创建新的执行线程

    千次阅读 2022-04-21 20:14:51
    创建新的执行线程(thread、Runnable) 核心概念 线程就是独立的执行路径 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程. main()称之为主线程,为系统的入口,用于执行整个程序 在一个...
  • Linux编译时make -j# 应该多少个线程

    千次阅读 2020-04-08 17:57:46
    make -j#编译时需要线程编译,节省时间。j后面的数字应该为CPU核心数的两倍。 比如,这个电脑。8-CORe,8核心,则make -j16 一个CPU核心,就是一个大脑,一个大脑可以同时做两件事。 这个就是英特尔公司超线程...
  • C# 开启新线程的几种方式 多线程

    千次阅读 2021-04-16 10:06:21
    最近用到了控制台程序,还要能中途停下来并保存参数,就需要开启一个线程来检查是否需要退出程序,总结一下实现多线程的几种方式 第一种,也是最常用的通过Thread类开启线程 public class Program { public ...
  • JAVA开启线程的四种方法

    千次阅读 2021-12-21 16:48:00
    * 1,定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。 * 2,创建Thread子类了的实例,即创建线程对象。本实例中是new一个...
  • Qt开启多线程

    千次阅读 2019-04-23 09:42:58
    Qt开启多线程,主要用到类QThread。有两种方法,第一种用一个类继承QThread,然后重新改写虚函数run()。当要开启新线程时,只需要实例该类,然后调用函数start(),就可以开启一条多线程。第二种方法是继承一个...
  • php 实现多线程

    千次阅读 2021-04-27 01:09:15
    可以想一下,WEB服务器本身都是支持多线程的。每一个访问者,当访问WEB页面的时候,都将调用新的线程,通过这一点我们可以利用WEB服务器自身的线程来解决PHP不支持多线程的问题。下面给出通过 fsockopen() 建立...
  • Python中的 线程

    万次阅读 2020-05-31 15:05:02
    1. 线程定义 线程是操作系统调度的最小单位 它被包含在进程之中,是进程中的实际运作单位 进程本身是无法自己执行的,要操作cpu,必须创建一个线程线程是一系列指令的集合 线程定义拓展 线程是操作系统能够进行...
  • ======创建线程的方式====== 继承Thead类,重写run()方法 实现Runnable类,重写run()方法 使用lombda 实现Callable类,重写call()方法 使用线程池 ======停止线程的方式====== 使用stop()方法 使用suspend()和resume()...
  • QT多线程-应对复杂数据处理、串口数据实时显示

    千次阅读 多人点赞 2019-07-31 16:55:41
    任何收发两端速度不一致的通讯,都需要在它们之间使用一个足够大的FIFO缓冲区。...◆多线程锁 ◆多线程日志 ◆日志文件占用的磁盘空间的可控性。 ◆日志中的时间包括毫秒 ◆传输的数据对应的每个字节到底的英文...
  • 线程的创建方式与开启一个线程

    千次阅读 2018-08-19 22:41:33
    线程与进程  在我们学习线程之前先来了解一下关于线程的一些知识  什么是进程  我们经常使用的软件他就是一个进程,一个正在运行的软件就是一个进程。  例如:一个工厂就相当于我们的一个进程。  什么是...
  • Unity3D学习4——多线程

    千次阅读 2021-06-20 18:33:45
    1、Thread类 主要的属性: 属性 描述 ...获取线程正在其中执行的当前上下文。...获取或设置当前线程的区域性。...线程的当前负责人 ...指示当前线程的执行状态 ...指示某个线程是否为后台线程 主要的方法: ...
  • Unity下的多线程研究

    千次阅读 2022-02-14 10:25:14
    1.Unity支持多线程的,只要线程不关闭,就一直运行。 2.编辑器模式下,如果线程不关闭,不管是切后台,还是当前场景关闭了,该线程都一直运行。 3.记得销毁线程。 命名空间: using System.Threading; 1.开启...
  • android 线程里面再新的的线程

    千次阅读 2016-03-04 11:36:18
    当 一个线程里面另外一个线程的时候,需要注意的地方,例如:  @Override  public void run() {  // TODO Auto-generated method stub  mTimeCount++;  mProgres
  • Runnable并不一定新开线程

    千次阅读 2014-12-13 18:52:20
    extends Thread一定新开一个线程,但Runnable不一定新开线程(所谓新开线程,指非UI线程): ① 如果是implements Runnable,像extends Thread一样,是新开了线程。 ②如果是匿名Runnable对象new Runnable() {...
  • 【python】多线程详解

    千次阅读 2021-01-29 18:22:57
    一、进程与线程关系一个进程至少包含一个线程。二、线程基础1、线程的状态线程有5种状态,状态转换的过程如下图所示:2、线程同步(锁)多线程的优势在于可以同时运行多个任务(至少感觉起来...那么,可能线程”set”...
  • 文章目录一、线程启动、结束、创建线程方法1. 创建线程的一般方法(1)thread() 一、线程启动、结束、创建线程方法 1. 创建线程的一般方法 主线程在从main开始执行,一旦主线程从main()返回,则整个程序(进程)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 789,704
精华内容 315,881
关键字:

怎么开线程