C#基础知识学习——多线程(Thread、Task、Sleep、Interrupt、线程同步处理locker、最大粒度、Monitor)（十八）
文章目录
- 线程生命周期
- 主线程
- 线程属性介绍
- 线程创建
-
- Thread
-
-
- 不带参数的方法创建线程
- 带参数的方法创建线程
-
- Task
-
-
- 直接通过task创建线程
- 通过factory创建线程
- 通过Task.run创建线程
-
- 前台线程与后台线程
- 线程常用方法
-
- sleep
- Interrupt
- Join
- 线程同步
-
- 未使用线程同步
- Locker
- 最大粒度
- Monitor
线程生命周期
新建（new 对象）
就绪（等待CPU调度）
运行（CPU正在运行）
阻塞（等待阻塞、同步阻塞等）
死亡（对象释放）
主线程
进程中第一个被执行得线程称为主线程，程序开始时，主线程自动创建。
线程属性介绍
| 属性 | 描述 |
|---|---|
| CurrentContext | 获取线程正在执行的当前上下文 |
| CurrentCulture | 获取或设置当前线程的区域性 |
| CurrentPrinciple | 获取或设置当前线程的负责人 |
| CurrentThread | 获取当前正在运行的线程 |
| CurrentUICulture | 获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源 |
| ExecutionContext | 获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息 |
| IsAlive | 获取一个值，该值指示当前线程的执行状态 |
| IsBackground | 获取或设置一个值，该值指示某个线程是否为后台线程 |
| IsThreadPoolThread | 获取一个值，该值指示线程是否属于托管线程池 |
| ManagedThreadId | 获取当前托管线程的唯一标识符 |
| Name | 获取或设置线程的名称 |
| Priority | 获取或设置一个值，该值指示线程的调度优先级 |
| ThreadState | 获取一个值，该值包含当前线程的状态 |
Thread.CurrentThread.Priority： 线程优先级，设置为高优先级的线程并不会一定在低优先级的线程之前执行，只是增加了优先执行的概率。
public static void Test()
{
Thread thread = Thread.CurrentThread;//获取当前执行得线程对象
thread.Name = "MainThread";
Console.WriteLine("this is {0},ID={1},优先级：{2}", thread.Name, Thread.CurrentThread.ManagedThreadId
,Thread.CurrentThread.Priority);
}
线程创建
创建线程方法：
Thread
不带参数的方法创建线程
Thread thread = new Thread(new ThreadStart(CreadThread));
带参数的方法创建线程
Thread thread=new Thread(new ParameterizedThreadStart(CreadThread!));
一般方法参数只能为object
public class ThreadCreadMethod
{
public static void CreadMethod01()
{
//不带参数的方法创建线程
Thread thread = new Thread(new ThreadStart(CreadThread));
thread.Name = "生出小兵逻辑";
thread.Start();
}
///带参数的线程
public static void CreadMethod02()
{
Thread thread=new Thread(new ParameterizedThreadStart(CreadThread!));
thread.Name = "生出野怪";
thread.Start(thread.Name);
}
public static void CreadThread()
{
for (int i = 0; i < 50; i++)
{
Console.WriteLine(Thread.CurrentThread.Name+":"+i);
}
}
/// Task
直接通过task创建线程
通过factory创建线程
通过Task.run创建线程
/// 前台线程与后台线程
默认情况下，创建的线程是前台线程。只要前台线程中的任何一个正在运行，它就可以使应用程序保持活动状态，而后台线程则不会。一旦所有前台线程完成，应用程序结束，所有仍在运行的后台线程终止。
设置IsBackground为true，即为后台线程。
public class BackGroundClassTest
{
public static void TestBackGround()
{
///演示前台线程
BackGroundTest backGroundTest = new BackGroundTest(10);
///创建前台线程
Thread fthread = new Thread(new ThreadStart(backGroundTest.RunLoop));
fthread.Name = "前台线程";
///演示后台线程
BackGroundTest backGroundTest1 = new BackGroundTest(20);
///创建前台线程
Thread bthread1 = new Thread(new ThreadStart(backGroundTest1.RunLoop));
bthread1.Name = "后台线程";
bthread1.IsBackground= true;
fthread.Start();
bthread1.Start();
}
}
class BackGroundTest
{
private int Count;
public BackGroundTest(int count)
{
this.Count = count;
}
public void RunLoop()
{
string threadname = Thread.CurrentThread.Name;
for (int i = 0; i < Count; i++)
{
Console.WriteLine($"{threadname}计数：{i}");
Thread.Sleep( 10 );
}
Console.WriteLine($"{threadname}完成计数");
}
}
Console.WriteLine("主线程开始");
BackGroundClassTest.TestBackGround();
Console.WriteLine("主线程结束");
当 bthread1.IsBackground= true时，即为后台线程时。运行结果为：
当 bthread1.IsBackground= false时，即为前台线程时。运行结果为：
线程常用方法
sleep
举个例子：访问资源失败时，需要等待一段时间继续访问，这个时候可以调用sleep方法
public class SleepClass1
{
public static void Test()
{
Console.WriteLine("Enter Main");
Thread thread1 = new Thread(new ThreadStart(Counter));
Thread thread2 = new Thread(new ThreadStart(Counter2));
thread2.Priority= ThreadPriority.Highest;
thread1.Start();
thread2.Start();
Console.WriteLine("EXIT Main");
}
public static void Counter()
{
Console.WriteLine("Enter Counter1");
for (int i = 0; i < 50; i++)
{
Console.Write(i + " ");
if (i==10)
{
Console.WriteLine();
Thread.Sleep(1000);
}
}
Console.WriteLine("Exit Counter1");
}
public static void Counter2()
{
Console.WriteLine("Enter Counter2");
for (int i = 51; i < 100; i++)
{
Console.Write(i + " ");
if (i ==70)
{
Console.WriteLine();
Thread.Sleep(1000);
}
}
Console.WriteLine("Exit Counter2");
}
}
运行结果
Interrupt
使用线程的Interrupt方法只可以中断处于 WaitSleepJoin 状态的线程，当线程状态不再为 WaitSleepJoin时，线程将恢复执行。
public class InterruptClass1
{
static Thread Threadsleep;
static Thread Threadwork;
public static void test()
{
Threadsleep = new Thread(new ThreadStart(SleepingThread));
Threadwork = new Thread(new ThreadStart(AwakeThread));
Threadsleep.Start();
Threadwork.Start();
}
public static void SleepingThread()
{
for (int i = 0; i < 50; i++)
{
Console.Write(i + " ");
if (i == 10 || i == 20 || i == 30)
{
Console.Write("sleeping-----" + i);
try
{
Thread.Sleep(20);
}
catch (ThreadInterruptedException er)
{
Console.WriteLine(er.Message);
}
}
}
}
/// 
Join
Join方法主要用来阻塞调用线程，直到某个线程终止或经过了指定时间为止,使得线程变得有序起来
public class JoinClass
{
public static void Test()
{
Thread thread = new Thread(ThreadMethod!);
thread.Name = "线程A";
Thread thread0 = new Thread(ThreadMethod!);
thread0.Name = "线程B";
thread.Start();
thread.Join();
thread0.Start();
thread0.Join();
for (int i = 0; i <= 3; i++)
{
Console.WriteLine($"我是主线程，循环了{i}次");
}
}
public static void ThreadMethod(object parameter)
{
for (int i = 0; i <= 3; i++)
{
Console.WriteLine($"我是{Thread.CurrentThread.Name}循环了{i}次");
Thread.Sleep(300);
}
}
}
未用join方法
用join方法
线程同步
多个线程使用同一资源，会出现数据竞争问题，因而需要线程同步来解决这一问题:locker、最大粒度、Monitor
未使用线程同步
public class ThreadSync
{
public static int Counter = 0;
/// 处理结果：出现数据竞争，数据结果出错
Locker
使用locker同步
public class ThreadSync
{
public static int Counter_locker = 0;
/// 处理结果：
最大粒度
[MethodImpl(MethodImplOptions.Synchronized)]
public class ThreadSync
{
static int money = 1000;
/// 处理结果：
Monitor
public class ThreadSync
{
static int money = 1000;
/// 结果:
