精华内容
下载资源
问答
  • 线程与进程

    千次阅读 2017-09-02 18:51:36
    线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可同属一个进程的其他的线程共享进程所拥有的全部资源.2.关系一个线程可以创建和撤销另一个线

    1.定义

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

    2.关系

    一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.
    相对进程而言,线程是一个更加接近于执行体的概念,它可以与同进程中的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。

    3.区别

    进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。
    1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
    2) 线程的划分尺度小于进程,使得多线程程序的并发性高。
    3) 另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。
    4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
    5) 从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

    4.优缺点

    线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源的管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。

    5 几种进程间的通信方式

    (1) 管道(pipe):管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有血缘关系的进程间使用。进程的血缘关系通常指父子进程关系。
    (2)有名管道(named pipe):有名管道也是半双工的通信方式,但是它允许无亲缘关系进程间通信。
    (3)信号量(semophore):信号量是一个计数器,可以用来控制多个进程对共享资源的访问。它通常作为一种锁机制,防止某进程正在访问共享资源时,其他进程也访问该资源。因此,主要作为进程间以及同一进程内不同线程之间的同步手段。
    (4)消息队列(message queue):消息队列是由消息组成的链表,存放在内核中 并由消息队列标识符标识。消息队列克服了信号传递信息少,管道只能承载无格式字节流以及缓冲区大小受限等缺点。
    (5)信号(signal):信号是一种比较复杂的通信方式,用于通知接收进程某一事件已经发生。
    (6)共享内存(shared memory):共享内存就是映射一段能被其他进程所访问的内存,这段共享内存由一个进程创建,但多个进程都可以访问,共享内存是最快的IPC方式,它是针对其他进程间的通信方式运行效率低而专门设计的。它往往与其他通信机制,如信号量配合使用,来实现进程间的同步和通信。
    (7)套接字(socket):套接口也是一种进程间的通信机制,与其他通信机制不同的是它可以用于不同及其间的进程通信。

    6 几种线程间的通信机制

    1、锁机制

         1.1 互斥锁:提供了以排它方式阻止数据结构被并发修改的方法。
         1.2 读写锁:允许多个线程同时读共享数据,而对写操作互斥。
         1.3 条件变量:可以以原子的方式阻塞进程,直到某个特定条件为真为止。对条件测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。
    

    2、信号量机制:包括无名线程信号量与有名线程信号量
    3、信号机制:类似于进程间的信号处理。
    线程间通信的主要目的是用于线程同步,所以线程没有象进程通信中用于数据交换的通信机制。

    7 进程共享数据的方式

    1、文件映射(Memory-Mapped Files)能使进程把文件内容当作进程地址间一块内存那样来对待
    2、共享内存(Shared Memory)实际就是文件映射的一种特殊情况
    3、命名管道(Named Pipe)是服务器进程和一个或多个客户进程之间通信的单向或双向管道
    4、邮件槽(Mailslots)提供进程间单向通信能力,任何进程都能建立邮件槽成为邮件槽服务器
    5、剪贴板(Clipped Board)为不同应用程序之间共享不同格式数据提供了一条捷径
    6、动态连接库(DLL)中的全局数据可以被调用DLL的所有进程共享

    8.线程安全与线程不安全

    线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。
    线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据

    管道

    http://blog.chinaunix.net/uid-26833883-id-3227144.html

    展开全文
  • Java进阶(四十三)线程与进程的区别

    万次阅读 多人点赞 2016-09-28 08:50:07
    Java进阶(四十三)线程与进程的区别1、线程的基本概念  概念:线程是进程中执行运算的最小单位,是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的...

    #Java进阶(四十三)线程与进程的区别
    ##1、线程的基本概念
      概念:线程是进程中执行运算的最小单位,是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。
      好处:

    • (1)易于调度。

    • (2)提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。

    • (3)开销少。创建线程比创建进程要快,所需开销很少。

    • (4)利于充分发挥多处理器的功能。通过创建多线程进程,每个线程在一个处理器上运行,从而实现应用程序的并发性,使每个处理器都得到充分运行。

    ##2、进程的基本状态及状态之间的关系

    ![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/297cce195d989e1d706795e628d42c45.png)

      详见博文《 Java进阶(四十一)多线程讲解》。
    ##3、线程和进程的关系以及区别
    ###进程和线程的关系

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

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

    • (3)处理机分给线程,即真正在处理机上运行的是线程。

    • (4)线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体.

    ###进程与线程的区别

    • (1)调度:线程作为调度和分配的基本单位,进程作为拥有资源的基本单位。

    • (2)并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可并发执行。

    • (3)拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但可以访问隶属于进程的资源。

    • (4)系统开销:在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。

    ##4、进程间通信的方式
    ###(1)管道(pipe)及有名管道(named pipe)
      管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系;有名管道也是半双工的通信方式,但是它允许无亲缘关系进程间的通信。
    ###(2)信号(signal)
      信号是在软件层次上对中断机制的一种模拟,它是比较复杂的通信方式,用于通知进程有某事件发生,一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。
    ###(3)信号量(semaphore)
      信号量是一个计数器,可以用来控制多个进程对共享资源的访问。它常作为一种锁机制,防止某进程正在访问共享资源时,其他进程也访问该资源。因此,主要作为进程之间及同一种进程的不同线程之间的同步和互斥手段。
    ###(4)消息队列(message queue)
      消息队列是由消息的链表,存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。具有写权限的进程可以按照一定的规则向消息队列中添加新信息;对消息队列有读权限的进程则可以从消息队列中读取信息。
    ###(5)共享内存(shared memory)
      可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间,不同进程可以及时看到对方进程中对共享内存中数据的更新。这种方式需要依靠某种同步操作,如互斥锁和信号量等。共享内存就是映射一段能被其他进程所访问的内存,这段共享内存由一个进程创建,但多个进程都可以访问。共享内存是最快的IPC方式,它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制,如信号量,配合使用,来实现进程间的同步和通信。
    ###(6)套接字(socket)
      这是一种更为一般的进程间通信机制,它可用于网络中不同机器之间的进程间通信,应用非常广泛。
    ##5、线程间通信的方式
    ###锁机制
      包括互斥锁、条件变量、读写锁

    • 互斥锁提供了以排他方式防止数据结构被并发修改的方法。
    • 读写锁允许多个线程同时读共享数据,而对写操作是互斥的。
    • 条件变量可以以原子的方式阻塞进程,直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

    ###信号量机制(Semaphore)
      包括无名线程信号量和命名线程信号量。
    ###信号机制(Signal)
      类似进程间的信号处理。
      线程间的通信目的主要是用于线程同步,所以线程没有像进程通信中的用于数据交换的通信机制。
    ###管道(Pipe)
      示例代码如下:

     package cn.edu.ujn.demo;
    
    import java.io.PipedReader;
    import java.io.PipedWriter;
    
    public class Piped {
    
    	public static void main(String[] args) throws Exception{
    		PipedWriter out = new PipedWriter();
    		PipedReader in = new PipedReader();
    		// 连接输入流和输出流,否则会报异常:java.io.IOException: Pipe not connected
    		out.connect(in);
    		Thread printThread = new Thread(new Print(in), "PrintThread");
    		printThread.start();
    		int receive = 0;
    		try {
    			while((receive = System.in.read()) != -1){
    				out.write(receive);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			out.close();
    		}
    	}
    
    }
    
    class Print implements Runnable{
    	private PipedReader in;
    	
    	public Print(PipedReader in){
    		this.in = in;
    	}
    	
    	public void run(){
    		int receive = 0;
    		try {
    			while((receive = in.read()) != -1){
    				System.out.print((char)receive);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    }
    

    ##6、同步和互斥的区别
      当有多个线程的时候,经常需要去同步这些线程以访问同一个数据或资源。例如,假设有一个程序,其中一个线程用于把文件写到内存,而另一个线程用于统计文件中的字符数。当然,在把整个文件调入内存之前,统计它的字符数是没有意义的。但是,由于每个操作都有自己的线程,操作系统会把两个线程当作是互不相干的任务分别执行,这样就可能在没有把整个文件装入内存时统计字符数。为解决此问题,你必须使两个线程同步工作。
      所谓同步,是指散布在不同进程之间的若干程序片断,它们的运行必须严格按照规定的某种先后次序来运行,这种先后次序依赖于要完成的特定的任务。如果用对资源的访问来定义的话,同步是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。
      所谓互斥,是指散布在不同进程之间的若干程序片断,当某个进程运行其中一个程序片段时,其它进程就不能运行它们之中的任一程序片段,只能等到该进程运行完这个程序片段后才可以运行。如果用对资源的访问来定义的话,互斥某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的。

    ![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/5ccfa1009c03947840196de4004ba295.png) ![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/d502db58434685a1eb635cabcccb0029.png) ![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/32ad2882d4917a68290c6c677e5e3229.png)
    展开全文
  • 线程与进程的特征及区别定义及特征进程  指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据和堆栈等组成的,是一个能独立运行的活动实体。进程的特征: 1.动态性:进程的实质是程序的一次...

    定义及特征

    进程

    指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令、数据和堆栈等组成的,是一个能独立运行的活动实体。

    进程的特征:

    • 1.动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的。
    • 2.并发性:任何进程都可以同其他进程一起并发执行。
    • 3.独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位。
    • 4.异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进。

    线程

    线程是进程中的一个实体,作为系统调度和分派的基本单位。

    多线程运行在同一进程的相同地址空间内,和采用多进程相比有以下优点:

    相比于进程线程的优点

    • 1.创建和撤销线程的开销较之进程要少。创建线程时只需要建立线程控制表相应的表目,或有关队列,而创建进程时,要创建PCB表和初始化,进入有关进程队列,建立它的地址空间和所需资源等。

    • 2.CPU在线程之间切换时的开销远比进程要少得多。因为切换线程都在同一地址空间内,只需要修改线程控制表或队列,不涉及地址空间和其他工作。

    • 3.线程机制增加了通讯的有效性。进程间的通讯往往要求内核的参与,以提供通讯机制和保护机制,而线程间的通讯是在同一进程的地址空间内,共享主存和文件,无需内核参与。

    三、进程和线程的区别

    (1)调度

    在传统的操作系统中,CPU调度和分派的基本单位是进程。而在引入线程的操作系统中,则把线程作为CPU调度和分派的基本单位,进程则作为资源拥有的基本单位,从而使传统进程的两个属性分开,线程编程轻装运行,这样可以显著地提高系统的并发性。同一进程中线程的切换不会引起进程切换,从而避免了昂贵的系统调用,但是在由一个进程中的线程切换到另一进程中的线程,依然会引起进程切换。

    (2)并发性

    在引入线程的操作系统中,不仅进程之间可以并发执行,而且在一个进程中的多个线程之间也可以并发执行,因而使操作系统具有更好的并发性,从而更有效地提高系统资源利用率和系统吞吐量。例如,在一个未引入线程的单CPU操作系统中,若仅设置一个文件服务进程,当它由于某种原因被封锁时,便没有其他的文件服务进程来提供服务。在引入线程的操作系统中,可以在一个文件服务进程中设置多个服务线程。当第一个线程等待时,文件服务进程中的第二个线程可以继续运行;当第二个线程封锁时,第三个线程可以继续执行,从而显著地提高了文件服务的质量以及系统吞吐量。

    (3)拥有资源

    不论是引入了线程的操作系统,还是传统的操作系统,进程都是拥有系统资源的一个独立单位,他可以拥有自己的资源。一般地说,线程自己不能拥有资源(也有一点必不可少的资源),但它可以访问其隶属进程的资源,亦即一个进程的代码段、数据段以及系统资源(如已打开的文件、I/O设备等),可供同一个进程的其他所有线程共享。

    (4)独立性

    在同一进程中的不同线程之间的独立性要比不同进程之间的独立性低得多。这是因为为防止进程之间彼此干扰和破坏,每个进程都拥有一个独立的地址空间和其它资源,除了共享全局变量外,不允许其它进程的访问。但是同一进程中的不同线程往往是为了提高并发性以及进行相互之间的合作而创建的,它们共享进程的内存地址空间和资源,如每个线程都可以访问它们所属进程地址空间中的所有地址,如一个线程的堆栈可以被其它线程读、写,甚至完全清除。

    (5)系统开销

    由于在创建或撤销进程时,系统都要为之分配或回收资源,如内存空间、I/O设备等。因此,操作系统为此所付出的开销将显著地大于在创建或撤消线程时的开销。类似的,在进程切换时,涉及到整个当前进程保存CPU环境的设置以及新被调度运行的CPU环境设置,而线程切换只需保存和设置少量的寄存器的内容,并不涉及存储器管理方面的操作,可见,进程切换的开销远大于线程切换的开销。此外,由于同一进程中的多个线程具有相同的地址空间,致使他们之间的同步和通信的实现也变得比较容易。在有的系统中,线程的切换、同步、和通信都无需操作系统内核的干预。

    (6)支持多处理机系统

    在多处理机系统中,对于传统的进程,即单线程进程,不管有多少处理机,该进程只能运行在一个处理机上。但对于多线程进程,就可以将一个进程中的多个线程分配到多个处理机上,使它们并行执行,这无疑将加速进程的完成。因此,现代处理机OS都无一例外地引入了多线程。

    展开全文
  • 例子简单了解线程与进程

    万次阅读 2020-03-29 16:11:18
    通过例子简单了解下线程与进程的概念,更多的的是怎么样去理解这两种东西。

    目录

    线程与进程概念

    进程

    线程

    线程与进程状态

    协程

    总体

    线程例

    基本操作

    全局变量操作

    进程例


    线程与进程概念

    进程

    进程(Process)是计算机中的程序关于某数据集合上的一次运行活动。是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中。

    线程

    线程(Thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流。

    线程与进程状态

    进程退出时该进程所产生的线程都会被强制退出并清除线程可与属于同一进程的其它线程共享进程所拥有的全部资源
    但是其本身基本上不拥有系统资源,只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。


    多进程适合在CPU 密集型操作(cpu 操作指令比较多,如科学计算,位数多的浮点运算)
    多线程适合在IO 密集型操作(读写数据操作较多的,比如爬虫)
    线程是并发进程是并行进程之间相互独立,是系统分配资源的最小单位,同一个进程中的所有线程共享资源。

    协程

    协程是用户态的轻量级线程,调度有用户控制,拥有自己的寄存器上下文和栈,切换基本没有内核切换的开销,切换灵活。

    总体

    1. 一个进程中可以并发多个线程,每条线程并行执行不同的任务。
    2. 进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。
    3. 线程是属于进程的,线程运行在进程空间内,同一进程所产生的线程共享同一内存空间。
    4. 线程是并发,进程是并行。

    线程例

    基本操作

    #线程基本操作
    import threading
    import time
    def cxk(n):
        print('运行线程:',n)
    
    for i in range(10):# 创建10个线程
        t = threading.Thread(target=cxk, args=(i,))    # 线程运行的函数和参数
        t.setDaemon(True) # 设置为守护线程(在主线程线程结束后自动退出,默认为False即主线程线程结束后子线程仍在执行)
        t.start() # 启动线程
    
    输出:
    运行线程: 0
    运行线程: 1
    运行线程: 2
    运行线程: 3
    运行线程: 4
    运行线程: 5
    运行线程: 6
    运行线程: 7
    运行线程: 8
    运行线程: 9

    全局变量操作

    import threading,time
    def cxk(n):
        global j
        j+=1
        time.sleep(1)
        print('运行线程:%s,变量j的情况:%s'%(n,j))
    j=-1
    for i in range(10):# 创建10个线程
        t = threading.Thread(target=cxk, args=(i,))    # 线程运行的函数和参数
        t.setDaemon(True) # 设置为守护线程(在主线程线程结束后自动退出,默认为False即主线程线程结束后子线程仍在执行)
        t.start() # 启动线程

    如果处理速度比较快并不会出现脏数据的情况
    >>>
    运行线程:0,变量j的情况:0
    运行线程:1,变量j的情况:1
    运行线程:2,变量j的情况:2
    运行线程:3,变量j的情况:3
    运行线程:4,变量j的情况:4
    运行线程:5,变量j的情况:5
    运行线程:6,变量j的情况:6
    运行线程:7,变量j的情况:7
    运行线程:8,变量j的情况:8
    运行线程:9,变量j的情况:9

    但是当我们每个进程睡眠加个进去,time.sleep(1),相当于处

    理速度比较慢的时候,就会变成下面这样,因为操作的全部线程执行完后第一个线程打印部分还在睡眠,当他打印j变量的时候全部线程已经执行完毕了
    >>>
    运行线程:0,变量j的情况:9
    运行线程:1,变量j的情况:9
    运行线程:3,变量j的情况:9
    运行线程:5,变量j的情况:9
    运行线程:4,变量j的情况:9
    运行线程:8,变量j的情况:9
    运行线程:7,变量j的情况:9
    运行线程:2,变量j的情况:9
    运行线程:9,变量j的情况:9
    运行线程:6,变量j的情况:9

    解决办法就是加锁

    # 线程锁
    import threading,time
    def cxk(n):
        lock.acquire()      # 开始锁
        global j
        j+=1
        time.sleep(1)
        print('运行线程:%s,变量j的情况:%s'%(n,j))
        lock.release()      # 结束锁
    j=-1
    lock = threading.RLock()    # 定义线程锁
    for i in range(10):# 创建10个线程
        t = threading.Thread(target=cxk, args=(i,))    # 线程运行的函数和参数
        t.setDaemon(True) # 设置为守护线程(在主线程线程结束后自动退出,默认为False即主线程线程结束后子线程仍在执行)
        t.start() # 启动线程
    
    
    #输出
    >>>
    运行线程:0,变量j的情况:0
    运行线程:1,变量j的情况:1
    运行线程:2,变量j的情况:2
    运行线程:3,变量j的情况:3
    运行线程:4,变量j的情况:4
    运行线程:5,变量j的情况:5
    运行线程:6,变量j的情况:6
    运行线程:7,变量j的情况:7
    运行线程:8,变量j的情况:8
    运行线程:9,变量j的情况:9

    那么多线程处理文件的时候会出现文件资源出现问题的情况吗?我们来为每个线程同时向同一个文件写十句话。

    import threading,time
    def cxk(n):
        with open('cxk.txt','a+') as f:
            for i in range(0,10):
                time.sleep(1)
                f.write('我是线程:%s \n'%str(n))
        print('线程:%s 写入成功'%str(n))
    for i in range(10):# 创建10个线程
        t = threading.Thread(target=cxk, args=(i,))    # 线程运行的函数和参数
        t.setDaemon(True) # 设置为守护线程(在主线程线程结束后自动退出,默认为False即主线程线程结束后子线程仍在执行)
        t.start() # 启动线程

    由图可以看出没什么问题,并没出现同一文件不能处理,我们加大处理速度试试,睡眠 。

    也没什么问题,就是线程完成速度不一样,并没出现第一个线程写完第一句第二个线程接着写第二句,但是这样看起来不像是并行,倒像是串行的。。。我就在想会不会是在并行的情况下,第一个线程睡眠时第二个线程也是同时处于睡眠状态,所以写入也是按顺序的。。。不过我在网上得到下面这一段话:
    """
    在Python的原始解释器CPython中存在着GIL,因此在解释执行Python代码时,会产生互斥锁来限制线程对共享资源的访问,直到解释器遇到I/O操作或者操作次数达到一定数目时才会释放GIL,所以有GIL效果就是:** 一个进程内同一时间只能允许一个线程进行运算 ** (这尼玛不就是单线程吗?)

    python的多线程只能在一个核心上跑(创始人没想到会有多核出现),就是单核的上下文切换,所以很鸡肋。
    于是协程在python大展拳脚,好多框架都是使用协程来解决多任务的,而不是线程(scrapy,tornado)。

    """
    最后似懂非懂,也就是说到底python的多线程就不是真正的并行。。。

    不过python的多线程确实能提升效率,并且使用tkinter时打开不同窗口使用多线程不会产生卡住状态,这篇博客也采用多线程处理,效率大大提升,还有以前的tkinter练习也基本用到了,有兴趣可以去看看。

    进程例

    进程我用的不多,因为我用notebook运行多进程时只有主进程会显示,子进程调用的函数没反应,只能打包成py文件去cmd下运行。

    #写入该句话,运行时直接生成py文件
    %%writefile cxkkxc.py
    import multiprocessing,time
    """
    进程各自持有一份数据,默认无法共享数据
    当创建进程时(非使用时),共享数据会被拿到子进程中,当进程中执行完毕后,再赋值给原值。
    """
    def cxk(n):
        with open('cxk2.txt','a+') as f:
            for i in range(0,10):
                f.write('我是进程:%s \n'%str(n))
                time.sleep(1)
        print('进程:%s 写入成功'%str(n))
        
    if __name__ == "__main__":
        for i in range(1,3):
            p = multiprocessing.Process(target = cxk, args = (i,))
            p.start()
            print("p.pid:", p.pid)
            print ("p.name:", p.name)
            print ("p.is_alive:", p.is_alive())

    这里我试用的也是打开文件的形式,只不过是以with open打开的,加了睡眠没有加锁也没出现资源共享问题,搞不懂搞不懂,可能with open 会自动关闭文件吧,每写完一句关闭第二个进程再打开写入。以后再探究探究。最近可能没空咯,参加了一个比赛,等忙完这阵再继续更。

     

     

    展开全文
  • 线程与进程区别 线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间; (2)资源...
  • 线程与进程详解

    2015-04-09 14:18:03
    线程与进程的比较:  线程具有许多传统进程具有的特征,所以,又称为轻型进程(Light-Weight Process)或进程元,相应地把传统进程称为重型进程(Heavy-Weight Process),传统进程相当于只有一个线程的任务。在引入了...
  • 线程与进程的概念

    2016-09-18 20:51:43
    线程与进程的概念进程:进程是指某个应用在处理机上的一次执行过程,是一个动态的概 念,是一个活动的实体。 线程:线程是进程的一部分,一个进程包含多个线程在运行。
  • 线程是什么?要理解这个概念,须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式,也就是说一个任务执行一小段时间后强制暂停去执行下一个任务,...
  • 线程与进程的比较

    2016-07-27 09:17:21
    线程与进程的比较 1) 调度。在传统的操作系统中,拥有资源和独立调度的基本单位都是进程。在引入线程的操作系统中,线程是独立调度的基本单位,进程是资源拥有的基本单位。在同一进程中,线程的切换不会引起进程...
  • 线程与进程的简单比较

    千次阅读 2018-03-20 20:32:03
    本篇文章主要对线程与进程之间的区别作一简单总结,从内核实现的区别,双方的地址空间、共享的数据、操作原语的比较和多线程与多进程的区别这几方面,做一简单说明。 1、Linux内核线程实现原理  Unix系统中,早期...
  • 关于线程与进程之间的关系,我觉得有一篇文章讲的很生动形象,这里贴出来供大家参考。进程与线程的一个简单解释 关于线程的理解,同样很生动形象的一个例子。我是一个线程 一. 线程、进程与线程的关系 1....
  • 线程与进程的关系

    万次阅读 2018-12-17 19:41:33
    线程进程1 线程进程2
  • 线程与进程那些事

    2014-12-19 21:12:32
    今天女朋友突然问了个问题,让我给她讲讲线程与进程,我一想,对于我们程序员来说线程与进程不是小儿科的问题么,可是说了半天女朋友都没弄明白,于是决定写这篇博客,把这二者说的清清楚楚,,明明白白的。...
  • 线程与进程的相似之处 线程在很多地方与进程相似。线程和进程都有ID、寄存器组、状态以及优先权。它们与之关联的信息块,称做线程块(thread block)和进程信息块(process information block)。线程和子进程共享父...
  • (精简)线程与进程的区别

    多人点赞 2017-09-19 15:31:11
    线程与进程的区别: 一个线程可以创建和撤销另一个线程; 一个程序至少有一个进程,一个进程至少有一个线程. 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。 多进程的程序要比多线程的程序健壮 ...
  • 线程与进程的区别

    千次阅读 2013-05-10 20:54:47
    线程与进程有 根本的不同。   每个进程 有其独立的 数据空间,文件描述符,以及进程的ID。 线程共享 一个数据空间,文件描述符,以及进程的ID。    进程间 可以 通过 管道,socket, 信号,退出/等待 以及 ...
  • 线程与进程的关系 一般将进程定义成一个正在运行的程序的一个实例,它由以下两部分构成。 一个内核对象,操作系统用它来管理进程。内核对象也是系统保存进程统计信息的地方。  一个地址空间,其中包含...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,460
精华内容 18,184
关键字:

线程与进程