day23目录：
	多线程
		进程的概述和多进程的意义
		线程的概述和多线程的意义
		JVM运行原理以及JVM启动的线程探讨
		实现多线程
		线程调度
		线程控制

23.01_多线程(进程概述及多进程的意义)(理解)
A:线程和进程
	要想说线程，首先必须得聊聊进程，因为线程是依赖于进程存在的。
B:进程概述
	什么是进程呢?通过任务管理器我们就可以看到进程的存在。
	概念：进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。
				  每一个进程都有它自己的内存空间和系统资源。
C:多进程的意义
	单进程计算机只能做一件事情。而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程)，
	所以我们常见的操作系统都是多进程操作系统。比如：Windows，Mac和Linux等，能在同一个时间段内执行多个任务。
	对于单核计算机来讲，游戏进程和音乐进程是同时运行的吗?不是。
	因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，且切换速度很快，
	所以，我们感觉游戏和音乐在同时进行，其实并不是同时执行的。多进程的作用不是提高执行速度，而是提高CPU的使用率。

23.02_多线程(线程概述及多线程的意义及并行和并发的区别)(理解)
A:什么是线程
	在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。是程序使用CPU的基本单位。所以，进程是拥有资源的基本单位， 线程是CPU调度的基本单位。
B:多线程有什么意义呢？
	多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。
	那么怎么理解这个问题呢?
	我们程序在运行的使用,都是在抢CPU的时间片(执行权),如果是多线程的程序,那么在抢到
	CPU的执行权的概率应该比较单线程程序抢到的概率要大.那么也就是说,CPU在多线程程序
	中执行的时间要比单线程多,所以就提高了程序的使用率.但是即使是多线程程序,那么他们
	中的哪个线程能抢占到CPU的资源呢,这个是不确定的,所以多线程具有随机性.
C:大家注意两个词汇的区别：并行和并发。
	前者是逻辑上同时发生，指在某一个时间内同时运行多个程序。
	后者是物理上同时发生，指在某一个时间点同时运行多个程序。

 什么是并发 ?
       并发 : 指应用能够交替执行不同的任务, 其实并发有点类似于多线程的原理, 多线程并非是如果你开两个线程同时执行多个任务。
 执行, 就是在你几乎不可能察觉到的速度不断去切换这两个任务, 已达到"同时执行效果", 其实并不是的, 只是计算机的速度太快, 我们无法察觉到而已. 就类似于你, 吃一口饭喝一口水, 以正常速度来看, 完全能够看的出来, 当你把这个过程以n倍速度执行时..可以想象一下.
        
 什么是并行 ?
     并行 : 指应用能够同时执行不同的任务, 例:吃饭的时候可以边吃饭边打电话, 这两件事情可以同时执行
        

23.03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(理解)
A:Java程序运行原理
	Java.exe 命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。
	该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
	所以 main方法运行在主线程中。
B:JVM的启动是多线程的吗:		JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

23.04_多线程(多线程程序实现的方式1)(掌握)
A:如何实现多线程:
如何实现呢?
	由于线程是依赖进程而存在的，所以我们应该先创建一个进程(JVM)出来。
  		而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。
  		但是Java是不能直接调用系统功能的，所以，我们没有办法直接实现多线程程序。
  		但是呢?Java可以去调用C/C++写好的程序来实现多线程程序。
  		由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，
  		然后提供一些类供我们使用。我们就可以实现多线程程序了。
	参考 Thread类
	B:多线程程序实现的方式1
		a:继承Thread类
		b:步骤及代码演示
		c:几个小问题：
			启动线程使用的是那个方法
			线程能不能多次启动
			run()和start()方法的区别
 我们启动线程使用不是run方法,而应该是start方法.使该线程开始执行；
	 Java 虚拟机调用该线程的 run 方法。
     
     为什么要重写run方法?
这个类是一个线程类,那么在这个类中我们可不可以写一些其他的方法呢?		
   我们可以在写其他的方法,那么其他方法中封装的代码都是需要被我们线程执行的吗? 不一定
   那么也就是run方法中封装应该是必须被线程执行的代码.
   
 run方法中的代码的书写原则: 一般是比较耗时的代码
 C:案例演示:	多线程程序实现的方式1		

​
23.05_多线程(获取和设置线程对象名称)(掌握)
A:Thread类的基本获取和设置方法
	public final String getName()//获取线程名称
	public final void setName(String name)//设置线程名称
	其实通过构造方法也可以给线程起名字
	思考：
		如何获取main方法所在的线程名称呢?
		public static Thread currentThread()//获取当前执行的线程
		/**
	 * 我们现在是想获取主线程的名称,那么我们可不可以先获取到主线程,
	 如果我们能获取到主线程,那么我们就可以调用getName方法获取对应的名称.
	 * 如何获取主线程呢? public static Thread currentThread()返回对当前正在执行的线程对象的引用。 
	 */
B:案例演示:	获取和设置线程对象名称

23.06_多线程(线程调度及获取和设置线程优先级)(了解)
A:线程的执行
	假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，
	线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？
B:线程有两种调度模型：
	分时调度模型   	所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
	抢占式调度模型   优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，
					优先级高的线程获取的 CPU 时间片相对多一些。 
					Java使用的是抢占式调度模型。
C:如何设置和获取线程优先级
	public final int getPriority() //获取线程的优先级
	public final void setPriority(int newPriority)//设置线程的优先级
D:案例演示:	获取和设置线程优先级
注意事项:  有的时候我们给线程设置了指定的优先级,但是该线程并不是按照优先级高的线程执行,那是为什么呢?
- 因为线程的优先级的大小仅仅表示这个线程被CPU执行的概率增大了.但是我们都知道多线程具有随机性,
- 所以有的时候一两次的运行说明不了问题

/**
 * 我们现在呢没有给线程设置优先级,那么java采用的是抢占式调度模型,那么这个线程应该存在一个默认的优先级.
 * 那么这个默认的优先级是多少呢,以及我们如何来获取线程的优先级.
 * 获取线程的优先级：
 * 		public final int getPriority()返回线程的优先级。 
 * 线程的默认优先级是5
 * 
 * 给线程设置优先级:范围是 1---10
 * 		public final void setPriority(int newPriority)
 */

23.07_多线程(线程控制之休眠线程)(掌握)
A:线程休眠:	public static void sleep(long millis) 线程休眠
B:案例演示:	线程休眠

​
23.08_多线程(线程控制之加入线程)(掌握)
A:加入线程:	public final void join()
	意思就是: 等待该线程执行完毕了以后,其他线程才能再次执行
	注意事项: 在线程启动之后,在调用方法
B:案例演示:	加入线程

23.09_多线程(线程控制之礼让线程)(了解)
A:礼让线程:	public static void yield():	暂停当前正在执行的线程对象，并执行其他线程。 
B:案例演示:	礼让线程
按照我们的想法,这个礼让应该是一个线程执行一次,但是通过我们的测试,效果好像不太明显.
那是为什么呢?
这个礼让是要暂停当前正在执行的线程,这个暂停的时间是相当短的,如果在这个线程暂停完毕以后,其他的线程还没有
抢占到CPU的执行权,那么这个时候这个线程应该再次和其他线程抢占CPU的执行权. 

23.10_多线程(线程控制之守护线程)(了解)
A:守护线程:	public final void setDaemon(boolean on):
	将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 
	该方法必须在启动线程前调用。 
B:案例演示:	守护线程 

 Java用户线程和守护线程
1.用户线程和守护线程的区别
    用户线程和守护线程都是线程，区别是Java虚拟机在所有用户线程dead后，程序就会结束。而不管是否还有守护线程还在运行，若守护线程还在运行，则会马上结束。很好理解，守护线程是用来辅助用户线程的，如公司的保安和员工，各司其职，当员工都离开后，保安自然下班了。
    
 2.用户线程和守护线程的适用场景
    由两者的区别及dead时间点可知，守护线程不适合用于输入输出或计算等操作，因为用户线程执行完毕，程序就dead了，适用于辅助用户线程的场景，如JVM的垃圾回收，内存管理都是守护线程，还有就是在做数据库应用的时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监听连接个数、超时时间、状态等。
    
 3.创建守护线程
    调用线程对象的方法setDaemon(true)，设置线程为守护线程。
            1)thread.setDaemon(true)必须在thread.start()之前设置。
            2)在Daemon线程中产生的新线程也是Daemon的。
            3)不是所有的应用都可以分配给Daemon线程来进行服务，比如读写操作或者计算逻辑。
    因为Daemon Thread还没来得及进行操作，虚拟机可能已经退出了。
    
 4.Java守护线程和Linux守护进程
    两者不是一个概念。Linux守护进程是后台服务进程，没有控制台。
    在Windows中，你可以运行javaw来达到释放控制台的目的，在Unix下你加&在命令的最后就行了。所以守护进程并非一定需要的。

23.11_多线程(线程控制之中断线程)(了解)
A:中断线程
	public final void stop():		停止线程的运行
	public void interrupt():		中断线程(这个翻译不太好),查看API可得当线程调用wait(),sleep(long time)方法的时候处于阻塞状态,可以通过这个方法清除阻塞

23.12_多线程(多线程程序实现的方式2)(掌握)
A:实现Runnable接口  这种方式扩展性强 实现一个接口 还可以再去继承其他类
	a:如何获取线程名称
	b:如何给线程设置名称
	c:实现接口方式的好处
		可以避免由于Java单继承带来的局限性。
B:案例演示:	多线程程序实现的方式2

23.12_多线程(多线程程序实现的方式3)(掌握)
A:实现 Callable 接口。 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
  
    B:执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类

C:实现步骤
	1.创建一个类实现Callable 接口
	2.创建一个FutureTask类将Callable接口的子类对象作为参数传进去
	3.创建Thread类,将FutureTask对象作为参数传进去
	4.开启线程

23.14_多线程(继承Thread类的方式卖电影票案例)(理解)
A:案例演示
	需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
	通过继承Thread类实现

 分析:
 a: 三个窗口其实就是3个线程
 b: 定义票的数量100张
 c: 创建线程对象,启动线程. 每卖一张这个票数应该--

23.15_多线程(实现Runnable接口的方式卖电影票)(理解)
A:案例演示
	需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
	通过实现Runnable接口实现

23.16_多线程(买电影票出现了同票和负数票的原因分析)(理解)
A:加入延迟
	我们前面讲解过电影院售票程序，从表面上看不出什么问题，但是在真实生活中，
	售票时网络是不能实时传输的，总是存在延迟的情况，所以，在出售一张票以后，需要一点时间的延迟
	改实现接口方式的卖票程序,每次卖票延迟100毫秒
B:出现问题了问题

23.17_多线程(线程安全问题的产生原因分析)(理解)
A:首先想为什么出现问题?(也是我们判断是否有问题的标准)
	是否是多线程环境
	是否有共享数据
	是否有多条语句操作共享数据
B:如何解决多线程安全问题呢?
	基本思想：让程序没有安全问题的环境。
	怎么实现呢?
	把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。


- 判断一个多线程应用程序是否有问题的标准:
- a: 是否是多线程环境
- b: 是否存在共享数据
- c: 是否存在多条语句同时操作共享数据
- 
- 我们现在这个程序是存在问题的,因为它满足上面的标准,那么我们只要将这个标准打乱,那么我们就可以解决这个问题.
- 而上面的标准中a , b是不能打乱的,因此我们只能对c做处理,关键是怎么处理? 如果我们把操作共享数据的多条语句看做
- 成一个整体,当一个线程执行这个整体的时候,其他的线程处于等待状态,也就说当一个线程执行这个整体的时候,其他线程
- 不能进行执行,那么怎么做到这个一点呢?
- 
- 需要使用同步代码块:
- 
- 格式: 	
- 
- synchronized(对象){//不能在括号了直接new 对象 new 了 就没效果
- 要被同步的代码 ;
- }

   *
- 这个同步代码块保证数据的安全性的一个主要因素就是这个对象
  	注意这个对象 要定义为静态成员变量 才能被所有线程共享
- 需要这个对象被所有的线程对象所共享
- 这个对象其实就是一把锁.
- 这个对象习惯叫做监视器

23.18_多线程(同步代码块的方式解决线程安全问题及解释以及同步的特点及好处和弊端)(掌握)
A:同步代码块的格式
	格式：
	
	synchronized(对象){ //同步代码代码块上的锁，是一个互斥锁。
	
		死循环
		需要同步的代码;
	}
	
	同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能
B:案例演示:	同步代码块的方式解决线程安全问题
C:案例解释:	再次给学生解释一遍如何解决了线程安全问题
D:同步的好处:	同步的出现解决了多线程的安全问题。
E:同步的弊端:	当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，
  因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。
  java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。
  线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。
  获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
  java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，
  当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，
  直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。
  java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，
  但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，
  类锁是用于类的静态方法或者一个类的class对象上的。
  我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，
  所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。
  但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，
  它只是用来帮助我们理解锁定实例方法和静态方法的区别的.

23.19_多线程(同步代码块的锁问题以及同步方法的应用和锁问题)(掌握)
A:案例演示:	同步代码块的锁问题
B:同步方法:	就是把同步关键字加到方法上
C:案例演示:	同步方法的锁对象是什么呢?
D:案例演示:	如果是静态方法，同步方法的锁对象又是什么呢?

同步代码块的锁对象: 	任意一个对象
同步方法的锁对象:   	是this
静态同步方法的锁对象:就是当前类对应的字节码文件对象

24.01_多线程(JDK5之后的Lock锁的概述和使用)(了解)
A:Lock锁的概述
	虽然我们可以理解同步代码块和同步方法的锁对象问题，
	但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
	为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
B:Lock和ReentrantLock
	void lock() 加锁 
	void unlock() 释放锁 
C:案例演示:	Lock锁的使用

建议总是 立即实践，使用 lock 块来调用 try，在之前/之后的构造中，最典型的代码如下： 

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

​
24.02_多线程(死锁问题概述和使用)(了解)
A:死锁问题概述
	如果出现了同步嵌套，就容易产生死锁问题
	是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
	同步代码块的嵌套案例
	 死锁: 两个或者两个以上的线程,在抢占CPU的执行权的时候,都处于等待状态
	 举例:	中国人和美国人一起吃饭
 		中国人使用的筷子
 		美国人使用的刀和叉
		中国人获取到了美国人的刀
	   美国人获取到了中国人的一根筷子
B:案例演示:	死锁问题代码演示

23.21_day23总结

经常遇到小伙伴提到python是单线程的，写代码的时候用多线程没有意义，今天与大家分享一下关于python的单线程与多线程相关理解。
首先   python是单线程的 这句话是不对的。
这里要提到一个概念：Python的全局解释器锁（GIL）
GIL是什么
需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL
帮python洗白了这个冤屈之后我们继续看为什么要用多线程
import threading
import time


def test1():
    for i in range(100000000):
        a = 100 - i


def test2():
    threads = []
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test1)
    t3 = threading.Thread(target=test1)
    t4 = threading.Thread(target=test1)
    threads.append(t1)
    threads.append(t2)
    threads.append(t3)
    threads.append(t4)

    threads[0].start()
    threads[1].start()
    threads[2].start()
    threads[3].start()

    threads[0].join()
    threads[1].join()
    threads[2].join()
    threads[3].join()


if __name__ == '__main__':
    t1 = time.time()
    test1()
    print('单线程一次：', time.time() - t1)  # 单线程一次： 3.872997760772705
    test1()
    print('单线程两次：', time.time() - t1)  # 单线程两次： 7.738230466842651
    test1()
    print('单线程三次：', time.time() - t1)  # 单线程三次： 11.609771013259888
    test1()
    print('单线程四次：', time.time() - t1)  # 单线程四次： 15.493367433547974
    t2 = time.time()
    test2()
    print('多线程四次：', time.time() - t2)  # 多线程四次： 15.55045747756958

这段代码执行后会发现4个线程同时执行所消耗的时间与一个线程执行消耗的时间是几乎一样的，到这里有的人会吐槽，这多线程也没提高效率，毛用没有。事实上python多线程在提高效率这块确实毛用没有。因为上边说了，GIL的存在，与单线程处理效率是一样的。
本质是这4个线程交替轮番执行，你执行一会儿，我执行一会儿，他执行一会儿…就是非常和谐的随机在单核上执行
那么问题来了：

是不是python就不需要多线程了呢？

答案是：

需要

追问：

那有啥用呢？

在python里多线程最开始就不是用来解决多核利用率问题的，这个交给操作系统就好了，多线程是解决IO阻塞问题和IO占用时CPU闲置问题。

举个简单的例子：

有一个应用有三个接口：

接口A处理需要花费10s(注意是纯粹的cpu处理消耗时间，不包含网络通信等消耗时间)
接口B处理需要花费5s(注意是纯粹的cpu处理消耗时间，不包含网络通信等消耗时间)
接口C处理需要花费2s(注意是纯粹的cpu处理消耗时间，不包含网络通信等消耗时间)

如果三个用户：小红，小明，小张

几乎同时，小红请求和A接口，小明请求了B接口，小张请求了C接口
单线程下：

小红10s收到结果，小明15s收到结果，小张17s收到结果

小张的接口虽然很快，只需要2s(相对很快)，但在单线程上要等前边小红，小明的处理完才能轮到他，所以他要等待17s才能收到结果，小张很郁闷，这么快的方法为啥要等这么长，所以这种设计明显是有问题的。

多线程下：

小红13s收到结果，小明7s收到结果，小张3s收到结果（三个方法交替轮番执行，数值是约等于）

这样虽然都慢一点，但小张和小明还是能接受的

结论：多线程使程序交替轮番执行，不会对后边的程序产生阻塞（这才是python应用多线程的根本目的）
补充：多线程提升不了CPU的处理效率，只能提供调用CPU的方案
所以如果运行瓶颈不在CPU运算而是在IO（网络）上，多线程显然很划算
总结：通常来说，多线程是一个好东西。不过，由于Python的GIL的限制，多线程更适合于I/O密集型应用（I/O释放了GIL，可以允许更多的并发），而不是计算密集型应用。对于后一种情况而言，为了实现更好地并行性，你需要使用多进程，以便让CPU的其他内核来执行。
以上就是我对python应用多线程的理解，有错误和不明确的地方欢迎大家留言！谢谢~

1.想要了解多线程，必须先了解线程，而想了解线程，必须了解进程，因为线程是依赖于进程而存储在的

2.什么是进程？
     通过任务管理器我们就看见了进程的存在
     而通过观察，我们发现只有运行的程序才会出现进程
     进程：就是正在运送的程序
               是系统进行资源分配和调用的独立单位。
               每一个进程都有它自己的内存空间和系统资源

3.多进程有什么意义？
         单进程的计算机只能做一件事情，而我们现在的计算机都可以进行多件事情：
         举例：一边游戏(游戏进程)，一边听音乐(音乐进程)
         也就是说现在的计算机都是支持多进程的，就可以在一个时间段内执行多个任务
         并且，可以提高CPU的使用率

      
      问题：
       一边玩游戏，一边听音乐时同时进行的吗？
       不是。因为单CPU在某一个时间点只能做一件事情
       而我们在玩游戏，或者听音乐，是CPU在做着程序间的高效切换让我们觉的是同时进行的。
       
4.什么是线程
     在一个进程内又可以执行多个任务，而每一个任务就们可以看成一个线程      
     线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位
     单线程：如果程序只有一个执行路径 。
     多线程：如果程序有多个执行路径
      
5.多线程有什么意义？
   多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率
   程序的执行其实都是在抢CPU的资源，或着说是在强CPU的执行权
   多个进程是在抢这个资源，而其中的某一个进程如果线程比较多，就会有更大的几率抢到CPU的执行权
   我们不敢保证那一个线程能够在那个时刻抢到，所以线程的执行有随机性

1:要想了解多线程,必须先了解线程,而要想了解线程,必须先了解进程,因为线程是依赖于进程而存在的。

2:什么进程?
	通过任务管理器我们看到了进程的存在。
	而通过观察,我们发现只有运行的程序才会出现进程。
	进程:正在运行的程序。
	进程 是系统进行资源分配和调用的独立单位。每一个进程都有它自已的内存空间和系统资源。

3:多进程有什么意义?
	单进程的计算机只能做一件事情,而我们现在的计算机都可以做多件事情。
	举例:一边玩游戏(游戏进程),一边听音乐(音乐进程)。
	也就是说现在的计算机都是支持多进程的,可以在一个时间段内执行多个任务。
	并且呢,可以提高CPU的使用率。
	
	问题:
		一边玩游戏,一边听音乐是同时进行的吗?
		不是,因为单CPU在某个时间点上只能做一件事情。
		而我们在玩游戏,或者听音乐的时候,是CPU在做程序间的高效切换让我们觉得是同时进行的。


4:什么是线程呢?
	在同一个进程内又可以执行多个任务,而这每一个任务我们就可以看成是一个线程。
	线程:是程序的执行单元,执行路径。是程序使用CUP的基本单位。
	单线程:如果程序只有一条执行路径。
	多线程:如果程序有多条执行路径。
	
5:多线程有什么意义呢?
	多线程的存在,不是提高程序的执行速度。其实是为了提高应用程序的使用率。
	程序的执行其实都是在抢CUP的资源,CPU的执行权。
	多个进程是在抢这个资源,而其中的某一个进程如果执行路径比较多,就会有更高的几率抢到CPU的执行权。	
	我们是不敢保证哪一个线程在哪个时刻抢到,所以线程的执行有随机性。
	举例:一个美女抛绣球(CPU执行权),A,B,C...等,ABC(进程)三个人抢绣球(CPU执行权),但是由于B(进程)使用分身术(多条执行路径),而他抢到绣球的机率将会很高,但是不一定能抢到