线程

学习笔记之线程

一、线程的本质

线程是程序的中的执行流，每个线程都有自己的专有寄存器（栈指针，程序计数器等），但代码是共享的，即不同的线程可以执行相同的函数。

线程本质：是一个为CPU执行准备的数据结构，也就是说，他负责告诉CPU要做什么事，并且为cpu提供这个事情的资源；

每个线程经过线程调度器，来让cpu执行Windows的线程只有七个优先级。所以调度器负责为CPU分配要执行的线程，以及线程执行时间，到达时间后，强制停止执行。

二、线程的安全性

cpu的执行速度太快了，所以为了快速访问，cpu不会直接读取线程的 工作缓存 ，而是将 工作缓存的内容读取到，cpu的耳机缓存中，以便快速访问。

而当cpu操作 不同线程，而不同线程会操作同一段数据，如果当cpu执行完某一个线程而未将数据返回到工作缓存时，再次执行下一线程时，此时线程中工作缓存数据未写回，产生线程安全问题。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;

namespace ThreadTest
{
    class ThreadTest
    {
        public object locker = new object();
        int count = 100;
        public void Sell()
        {
            //Console.WriteLine("当前进入的线程：" + System.Threading.Thread.CurrentThread.Name);
            while (count > 0)
            {
                lock (locker)//不同线程执行这个代码时只要确保是同一个对象就可以了，如： this.GetType()  /  static变量 / 相同实例变量
                {
                    count--;
                    Console.WriteLine(System.Threading.Thread.CurrentThread.Name + ",剩{0}张~！", count);
                }
            }
        }

        #region 1.0测试 实例方法里的锁
        /// <summary>
        /// 1.0测试 实例方法里的锁
        /// </summary>
        /// <param name="oLoker"></param>
        public void TestSellMany()
        {
            ThreadTest tt = new ThreadTest();
            Thread t1 = new Thread(tt.Sell);
            t1.Name = "t1";
            t1.IsBackground = true;

            Thread t2 = new Thread(tt.Sell);
            t2.Name = "t2";
            t2.IsBackground = true;

            t1.Start();
            t2.Start();
        } 
        #endregion
        //----------------------------------------------------------------

        static int countStatic = 100;
        public static object lockerStatic = new object();
        public static void SellStatic(object oLoker)
        {
            while (countStatic > 0)
            {
                lock (oLoker)//不同线程执行这个代码时只要确保是同一个对象就可以了，如： this.GetType()  /  static变量 / 相同实例变量
                {
                    countStatic--;
                    Console.WriteLine(System.Threading.Thread.CurrentThread.Name + ",剩{0}张~！", countStatic);
                }
            }
        }

        #region 2.0 测试 静态方法里的锁
        /// <summary>
        /// 测试 静态方法里的锁
        /// </summary>
        public void TestSellManyStatic()
        {
            ThreadTest tt = new ThreadTest();
            Thread t1 = new Thread(SellStatic);
            t1.Name = "t1";
            t1.IsBackground = true;

            Thread t2 = new Thread(SellStatic);
            t2.Name = "t2";
            t2.IsBackground = true;

            object lok = new object();
            t1.Start(lok);
            t2.Start(lok);
        } 
        #endregion
        //----------------------------------------------------------------
        public void SellByMonitor()
        {
            while (countStatic > 0)
            {
                bool isGetLoker = false;
                try
                {
                    Monitor.Enter(locker, ref isGetLoker);//尝试获取锁，如果获取成功，isGetLoker=true，否则=false
                    countStatic--;
                    Console.WriteLine(System.Threading.Thread.CurrentThread.Name + ",剩{0}张~！", countStatic);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    if (isGetLoker)//如果有锁，就解锁；否则，没有锁，就不存在 解锁！
                    {
                        Monitor.Exit(locker);
                    }
                }
            }
        }
        #region 3.0 测试 Monitor
        /// <summary>
        /// 3.0 测试 Monitor
        /// </summary>
        public static void TestMonitor()
        {
            ThreadTest tt = new ThreadTest();
            Thread t1 = new Thread(tt.SellByMonitor);
            t1.Name = "t1";
            t1.IsBackground = true;

            Thread t2 = new Thread(tt.SellByMonitor);
            t2.Name = "t2";
            t2.IsBackground = true;

            t1.Start();
            t2.Start();
        } 
        #endregion

        int forNum = 0;
        public void PrintNum(int num)
        {
            Console.WriteLine(System.Threading.Thread.CurrentThread.Name+",哈哈哈~~~");
            Console.WriteLine(num);
        }

        //同步方法 特性
        [MethodImpl(MethodImplOptions.Synchronized)]
        public void MethodLock()
        {
            for (; forNum < 100; forNum++)
            {
                PrintNum(forNum);
            }
        }

        #region 4.0 测试同步方法
        //测试同步方法
        public static void TestMothodLock()
        {
            ThreadTest tt = new ThreadTest();
            Thread t1 = new Thread(tt.MethodLock);
            t1.Name = "t1";
            t1.IsBackground = true;

            Thread t2 = new Thread(tt.MethodLock);
            t2.Name = "t2";
            t2.IsBackground = true;

            t1.Start();
            t2.Start();
        } 
        #endregion
        //-------------------------------------------------------------------------
        static object locker1 = new object();
        static object locker2 = new object();

        #region 5.0测试死锁
        //5.0测试死锁
        public static void TestDeadLock()
        {
            new Thread(() =>
            {
                Console.WriteLine("线程1开始执行");
                lock (locker1)   //获取锁locker1
                {
                    Console.WriteLine("线程1获取锁1");
                    Thread.Sleep(1000);
                    lock (locker2) //尝试获取locker2
                    {
                        Console.WriteLine("线程1获取锁2");
                    }
                }
            }).Start();

            new Thread(() =>
            {
                Console.WriteLine("线程2开始执行");
                lock (locker2) //获取锁locker2
                {
                    Console.WriteLine("线程2获取锁2");
                    Thread.Sleep(1000);
                    lock (locker1) //尝试获取locker1
                    {
                        Console.WriteLine("线程2获取锁1");
                    }
                }
            }).Start();
        } 
        #endregion
        //-------------------------------------------------------------------------
        #region 6.0 测试 线程通信
        /// <summary>
        /// 6.0 测试 线程通信
        /// </summary>
        public static void TestProCus()
        {
            Dog d = new Dog();
            Productor p = new Productor(d);
            Customer c = new Customer(d);

            Thread trhPro = new Thread(p.ProductDog);
            trhPro.IsBackground = true;
            trhPro.Name = "t1";

            Thread trhCus = new Thread(c.ShowDogInfo);
            trhCus.IsBackground = true;
            trhCus.Name = "t2";

            trhPro.Start();
            trhCus.Start();
            Console.ReadLine();
            trhPro.Abort();
            trhCus.Abort();
        } 
        #endregion
        //-------------------------------------------------------------------------

        public static void Mother()
        {
            Console.WriteLine("买菜~~~");
            Console.WriteLine("切菜~~~");
            Console.WriteLine("做菜~~~");
            Console.WriteLine("做饭~~~判断是否有米，发现木有米勒，就叫儿子去买米......");
            Thread thrSon = new Thread(Son);
            thrSon.IsBackground = true;
            thrSon.Start();
            thrSon.Join();//强制阻断其他线程执行，先执行当前线程thrSon
            Console.WriteLine("儿子买米回来了~~~");
            Console.WriteLine("淘米~~~");
            Console.WriteLine("煮饭~~~");
            Console.WriteLine("吃饭~~~");
        }

        public static void Son()
        {
            Console.WriteLine("妈妈叫我去买米~~~");
            Console.WriteLine("买米哦~~~");
            for (int i = 0; i < 5; i++) 
            {
                System.Threading.Thread.Sleep(500);
                Console.WriteLine("{0}秒钟......",i);
            }
            Console.WriteLine("买好米勒，回家~~~！");
        }

        public static void TestJoin()
        {
            Thread thrMother = new Thread(Mother);
            thrMother.IsBackground = true;
            thrMother.Start();
        }

        public static void Main(string[] ar)
        {
            //TicketSeller t1 = new TicketSeller("1台");
            //TicketSeller t2 = new TicketSeller("2台");
            TestJoin();
            Console.ReadLine();
        }

    }

    /// <summary>
    /// 产品
    /// </summary>
    public class Dog
    {
        public static object lockCommunicate = new object();

        public string name;
        public int age;
    }

    /// <summary>
    /// 生产者
    /// </summary>
    public class Productor
    {
        Dog myDog;
        public Productor(Dog d)
        {
            myDog = d;
        }

        bool type = true;
        public void ProductDog()
        {
            while (true)
            {
                lock (Dog.lockCommunicate)
                {
                    if (type)
                    {
                        myDog.name = "Ruiky";
                        myDog.age = 2;
                    }
                    else
                    {
                        myDog.name = "瑞奇";
                        myDog.age = 1;
                    }
                    type = !type;
                    Monitor.Pulse(Dog.lockCommunicate);
                    Monitor.Wait(Dog.lockCommunicate);
                }
            }
        }
    }

    public class Customer
    {
        Dog myDog;
        public Customer(Dog d)
        {
            myDog = d;
        }

        public void ShowDogInfo()
        {
            while (true)
            {
                lock (Dog.lockCommunicate)
                {
                    Console.WriteLine("我是{0},年龄{1}", myDog.name, myDog.age);
                    Monitor.Pulse(Dog.lockCommunicate);
                    Monitor.PulseAll(Dog.lockCommunicate);
                    Monitor.Wait(Dog.lockCommunicate);
                }
            }
        }
    }

    public class TicketSeller
    {
        public static int count = 100;
        public static object locker = new object();

        public TicketSeller(string taiName)
        {
            Thread t2 = new Thread(Sell);
            t2.Name = taiName;// "2号台";
            t2.IsBackground = true;
            t2.Start();
        }

        public void Sell()
        {
            while (count > 0)
            {
                lock (this)
                {
                    TicketSeller.count--;
                    Console.WriteLine(System.Threading.Thread.CurrentThread.Name + ",剩{0}张~！", count);
                }
            }
        }

        public void Sell2()
        {
            lock (locker)
            {
 
            }
        }
    }
}