线程、进程及其相关内容的完整总结

一、概念

进程（process）：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。进程是系统进行资源分配和调度的一个独立单位。
进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。
进程状态：进程有三个状态，就绪、运行和阻塞。就绪状态其实就是获取了出cpu外的所有资源，只要处理器分配资源就可以马上执行。就绪状态有排队序列什么的，排队原则不再赘述。运行态就是获得了处理器分配的资源，程序开始执行。阻塞态，当程序条件不够时候，需要等待条件满足时候才能执行，如等待i/o操作时候，此刻的状态就叫阻塞态。
线程（thread）：进程中所包含的一个或多个执行单元。
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。
线程状态：线程的状态及各个状态间的转换可以用下图来表示：

线程在Running的过程中可能会遇到阻塞(Blocked)情况
1.调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
2.调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
3.对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。
此外，在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。

---

二、进程与线程的关系

一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
计算机的核心是CPU，它承担了所有的计算任务。可以想象它就像一座工厂，时刻在运行。假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。
进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。在工厂的一个车间里，可以有很多工人。他们协同完成一个任务。
线程就好比车间里的工人。一个进程可以包括多个线程。车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。
可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫”互斥锁”（mutex），防止多个线程同时读写某一块内存区域。
还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做”信号量”（Semaphore），用来保证多个线程不会互相冲突。
不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。
还可以这样理解他们之间的关系：进程就是包换上下文切换的程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文。但是由于进程颗粒度太大，每次都要有上下的调入，保存，调出。为了程序执行的快速，稳定，我们需要把实际进程分成多个块组合而成。上述表示可以转换为：CPU加载上下文，开始执行程序A的a小段，然后执行A的b小段，然后再执行A的c小段，最后CPU保存A的上下文。

---

三、访问资源简介

在多线程应用（一个或多个处理器）的计算中会使用到同步这个词。实际上，这些应用程序的特点就是它们拥有多个执行单元，而这些单元在访问资源的时候可能会发生冲突。线程间会共享同步对象，而同步对象的目的在于能够阻塞一个或多个线程，直到另一个线程使得某个特定条件得到满足。例如在java中允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。在同步机制中，需要了解竞态条件和死锁的相关概念。
竞态条件指的是一种特殊的情况，在这种情况下各个执行单元以一种没有逻辑的顺序执行动作，从而导致意想不到的结果。经典的竞态条件的例子就是生产者/消费者模型。生产者通常使用同一个物理内存空间保存被生产的信息。一般说来，我们不会忘记在生产者与消费者的并发访问之间保护这个空间。容易被我们忘记的是生产者必须确保在生产新信息前，旧的信息已被消费者所读取。如果我们没有采取相应的预防措施，我们将面临生产的信息从未被消费的危险。
死锁指的是由于两个或多个执行单元之间相互等待对方结束而引起阻塞的情况。例如：
一个线程T1获得了对资源R1的访问权。
一个线程T2获得了对资源R2的访问权。
T1请求对R2的访问权但是由于此权力被T2所占而不得不等待。
T2请求对R1的访问权但是由于此权力被T1所占而不得不等待。
T1和T2将永远维持等待状态，此时程序就会陷入了死锁。若一个类的每个实例在同一时间不能被一个以上的线程所访问，则该类称之为一个线程安全的类。
相关条件中涉及到的具体实现类和方法这里就不详细介绍。高级语言对于多线程通信有一套完整的程序语言设计方法。

---

四、实例

多线程写日志。

using System;using System.Collections.Generic;using System.IO;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks;namespace ConsoleApplication1{    class Program    {        static void Main(string[] args)        {            Thread t1 = new Thread(Working);            t1.Name = "Thread1";            Thread t2 = new Thread(Working);            t2.Name = "Thread2";            Thread t3 = new Thread(Working);            t3.Name = "Thread3";            // 依次启动3个线程。            t1.Start();            t2.Start();            t3.Start();            Console.ReadKey();        }        // 每个线程都同时在工作        static void Working()        {            // 模拟1000次写日志操作            for (int i = 0; i < 1000; i++)            {                //  异步写文件                logger.Write(Thread.CurrentThread.Name + " writes a log: " + i + ", on " + DateTime.Now.ToString() + ".\n");            }// 做一些其它的事件            for (int i = 0; i < 100; i++) { }        }    }    public  class logger    {        private Queue<Action> _queue;        //写日志线程        private Thread _loggingThread;        //信号器        private ManualResetEvent _hasNew;        // 使用单例模式，保持一个Logger对象        private static readonly logger _logger = new logger();        private static logger GetInstance()        {            /* 不安全代码            lock (locker) {                if (_logger == null) {                    _logger = new Logger();                }            }*/            return _logger;        }        private logger()        {            _queue = new Queue<Action>();            _hasNew = new ManualResetEvent(false);            _loggingThread = new Thread(Process);            _loggingThread.IsBackground = true;            _loggingThread.Start();        }        private void Process()        {            while (true)            {                //等待信号,阻塞线程                _hasNew.WaitOne();                //接收到信号，信号关闭，重置                _hasNew.Reset();                Thread.Sleep(100);                Queue<Action> queueCopy;                lock (_queue)                {                    queueCopy = new Queue<Action>(_queue);                    _queue.Clear();                }                foreach (var action in queueCopy)                {                    action();                }            }        }        private void WeiteLog(string content)        {            lock (_queue)            {                _queue.Enqueue(() => File.AppendAllText("log.txt", content));            }            _hasNew.Set();        }        public static void Write(string content)        {            Task.Run(() => GetInstance().WeiteLog(content));        }    }}