windows多线程编程

进程共同实现某个任务或者共享计算机资源, 它们之间存在两种关系:

1.同步关系, 指为了完成任务的进程之间, 因为需要在某些位置协调它们的执行顺序而等待, 传递消息产生的制约关系.

2.互斥关系, 进程间因相互竞争使用独占型资源所产生的制约关系, 如一个进程使用打印机,另一个进程必须等待它使用完后才可使用.

临界资源: 一次仅允许一个进程使(必须互斥使用)的资源, 如独占型硬件资源.....

临界段: 指各进程必须互斥执行的程序段, 该程序段实施对临界资源的操作.

关键区对象为:CRITICAL_SECTION 当某个线程进入关键区之后,其他线程将阻塞等待,直到该线程释放关键区的拥有权.

#include <windows.h>
#include <stdio.h>

static int number=;
CRITICAL_SECTION CriticalSection;

DWORD WINAPI ThreadOne(LPVOID lpParameter)
{
    printf("窗口1售票开始:\n");
    while()
    {
         EnterCriticalSection(&CriticalSection);
         if(number>)
         {
             printf("窗口1售出第%d张票...\n",number);
             number--;
             Sleep();
         }
         LeaveCriticalSection(&CriticalSection);
         Sleep();
    }
    return ;
}
 DWORD WINAPI ThreadTwo(LPVOID lpParameter)
 {
     printf("窗口2售票开始:\n");
     while()
     {
         EnterCriticalSection(&CriticalSection);
         if(number>)
         {
             printf("窗口2售出第%d张票...\n",number);
             Sleep();
             number--;
         }
         LeaveCriticalSection(&CriticalSection);
         Sleep();
     }
     return ;
 }

 int main()
 {
     HANDLE HOne,HTwo;
     InitializeCriticalSection(&CriticalSection);
     printf("***********************vpoet******************\n");
     HOne=CreateThread(NULL,,ThreadOne,NULL,,NULL);
     HTwo=CreateThread(NULL,,ThreadTwo,NULL,,NULL);
     CloseHandle(HOne);
     CloseHandle(HTwo);
     while(TRUE)
     {
         if(number==)
         {
             printf("不好意思,票卖完了!\n");
             DeleteCriticalSection(&CriticalSection);
             return ;
         }
         else
         {
             continue;
         }
     }

     return ;
 }

信号量机制: 由信号量和P操作,V操作两部分组成, 可以解决互斥与同步问题. 信号量(s)为一个整型变量, 只能被两个标准原语访问, 分别记为P操作和V操作.

定义如下:

 P(s){
     while s <=
         ; //空操作
          s = s - ;
 }

V(s){
    s =s + ;
}

信号量可以解决n个进程的临界段问题, n个进程共享一个公共变量mutex, 其初值为 1 , 任意一个进程Pi的结果如下:

do{
    P(mutex);
    critical secition
    V(mutex);
    non critical secition
}while();

信号量也可以解决进程间同步问题.

利用信号量解决线程同步问题

 #include <windows.h>
 #include <stdio.h>

 static int number=;
 HANDLE Sem;

 DWORD WINAPI ThreadOne(LPVOID lpParameter)
 {
     printf("窗口1售票开始:\n");
     while()
     {
          // 信号量 >  0, 减去 1
         WaitForSingleObject(Sem,INFINITE);
         if(number>)
         {
             printf("窗口1售出第%d张票...\n",number);
             number--;
             Sleep();
         }
         // 信号量  < 0 , 加上 1
         ReleaseSemaphore(Sem,,NULL);
         Sleep();
     }
     return ;
 }
 DWORD WINAPI ThreadTwo(LPVOID lpParameter)
 {
     printf("窗口2售票开始:\n");
     while()
     {
         WaitForSingleObject(Sem,INFINITE);
         if(number>)
         {
             printf("窗口2售出第%d张票...\n",number);
             Sleep();
             number--;
         }
         ReleaseSemaphore(Sem,,NULL);
         Sleep();
     }
     return ;
 }

 int main()
 {
     HANDLE HOne,HTwo;

     printf("***********************vpoet******************\n");
     HOne=CreateThread(NULL,,ThreadOne,NULL,,NULL);
     HTwo=CreateThread(NULL,,ThreadTwo,NULL,,NULL);
     //创建信号量, 初始为 1 , 最大计数为 1
     Sem=CreateSemaphore(NULL,,,NULL);
     CloseHandle(HOne);
     CloseHandle(HTwo);
     while(TRUE)
     {
         if(number==)
         {
             printf("不好意思,票卖完了!\n");
             CloseHandle(Sem);
             return ;
         }
         else
         {
             continue;
         }
     }

     return ;
 }

信号量的具体实现:与进程调度相结合, 消除忙等待现象.

基本思想:

在P操作循环等待的地方介入放弃处理机, 进入等待对了动作.

在V操作时, 从等待队列中摘取进程变为就绪.

信号量定义

typedef struct{
       int:value;  一个数值型变量
       struct process *L;一个PCB队列
       } Semaphore
Semaphore S;

P操作

   P(S):      S.Value=S.value－;
              if S.value< then 保存现场，
              将本进程挂入S.L队列，等待重新调度

请求分配一个S代表的资源, 若S.value < 0, 代表系统无此资源, 申请者阻塞.

V操作

   V(S):          S.value:=value+
                  if S.value≤ then 从S.L队列
                  取一进程，挂入就绪队列。

进程释放一个S代表的资源, 若S.value <= 0, 表示尚有进程在等待S而被阻塞, 所有要唤醒其一.

管程

共享资源用共享数据结构表示, 把分散的对共享资源的临界段集中于管程中, 管程中的临界程序一次只允许一个进程调用.

主要构成:共享数据结构,  对共享数据结构操作的一组函数, 数据结构的初始化程序.

互斥对象实现线程同步

互斥对象的所有权轮换给两个线程

#include <windows.h>
#include <stdio.h>

static int number=;
HANDLE Mutex;

DWORD WINAPI ThreadOne(LPVOID lpParameter)
{
    while()
    {
        //等待互斥对象有多有权才返回
        WaitForSingleObject(Mutex,INFINITE);
        if(number>)
        {
            printf("窗口1售出第%d张票...\n",number);
            number--;
            Sleep();
        }
        //释放互斥对象所有权
        ReleaseMutex(Mutex);
    }
    return ;
}
DWORD WINAPI ThreadTwo(LPVOID lpParameter)
{
    while()
    {
        WaitForSingleObject(Mutex,INFINITE);
        if(number>)
        {
            printf("窗口2售出第%d张票...\n",number);
            Sleep();
            number--;
        }
        ReleaseMutex(Mutex);
    }
    return ;
}

int main()
{
    HANDLE HOne,HTwo;
    Mutex=CreateMutex(NULL,FALSE,NULL);
    printf("***********************vpoet******************\n");
    HOne=CreateThread(NULL,,ThreadOne,NULL,,NULL);
    printf("窗口1售票开始:\n");
    HTwo=CreateThread(NULL,,ThreadTwo,NULL,,NULL);
    printf("窗口2售票开始:\n");
    CloseHandle(HOne);
    CloseHandle(HTwo);
    while(TRUE)
    {
        if(number==)
        {
            printf("不好意思,票卖完了!\n");
            CloseHandle(Mutex);
            return ;
        }
        else
        {
            continue;
        }
    }

    return ;
}