一、实验目的
在掌握基于消息的windows程序结构和多线程程序设计方法的基础上，设计一个多线程同步的程序。使学生能够从程序设计的角度了解多线程程序设计的方法和在windows系统下多线程同步互斥的机制。
二、实验内容
1．理解Windows程序设计的基本思想，理解基于消息的程序设计方法，能够设计出简单的基于事件的windows程序，完成基本控件的使用
2．结合操作系统中信号量与互斥体的概念，在MFC中找到对应的相关类
3．设计一个多线程同步的程序，
多线程概述
进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。
线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。
每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。
多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。这一点在多线程编程时应该注意。
Win32 SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。Visual C++ 6.0中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。
VC中提供线程同步的方法：
临界区（CCriticalSection）
事件（CEvent）
互斥量（CMutex）
信号量（CSemaphore）
A、使用CCriticalSection 类
当多个线程访问一个独占性共享资源时,可以使用“临界区”对象。任一时刻只有一个线程可以拥有临界区对象，拥有临界区的线程可以访问被保护起来的资源或代码段，其他希望进入临界区的线程将被挂起等待，直到拥有临界区的线程放弃临界区时为止，这样就保证了不会在同一时刻出现多个线程访问共享资源。
CCriticalSection类的用法非常简单，步骤如下：
定义CCriticalSection类的一个全局对象（以使各个线程均能访问），如CCriticalSection critical_section；
在访问需要保护的资源或代码之前，调用CCriticalSection类的成员Lock（）获得临界区对象：critical_section.Lock();
在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象，则调用Lock()的线程获得临界区；否则，线程将被挂起，并放入到一个系统队列中等待，直到当前拥有临界区的线程释放了临界区时为止。访问临界区完毕后，使用CCriticalSection的成员函数Unlock()来释放临界区：critical_section.Unlock();
再通俗一点讲，就是线程A执行到critical_section.Lock();语句时，如果其它线程(B)正在执行critical_section.Lock();语句后且critical_section. Unlock();语句前的语句时，线程A就会等待，直到线程B执行完critical_section. Unlock();语句，线程A才会继续执行。
B、使用CEvent 类
CEvent 类提供了对事件的支持。事件是一个允许一个线程在某种情况发生时，唤醒另外一个线程的同步对象。例如在某些网络应用程序中，一个线程（记为A）负责监听通讯端口，另外一个线程（记为B）负责更新用户数据。通过使用CEvent 类，线程A可以通知线程B何时更新用户数据。每一个CEvent 对象可以有两种状态：有信号状态和无信号状态。线程监视位于其中的CEvent 类对象的状态，并在相应的时候采取相应的操作。
在MFC中，CEvent 类对象有两种类型：人工事件和自动事件。一个自动CEvent 对象在被至少一个线程释放后会自动返回到无信号状态；而人工事件对象获得信号后，释放可利用线程，但直到调用成员函数ReSetEvent()才将其设置为无信号状态。在创建CEvent 类的对象时，默认创建的是自动事件。CEvent 类的各成员函数的原型和参数说明如下：
1、CEvent(BOOL bInitiallyOwn=FALSE,
BOOL bManualReset=FALSE,
LPCTSTR lpszName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);
bInitiallyOwn:指定事件对象初始化状态，TRUE为有信号，FALSE为无信号；bManualReset：指定要创建的事件是属于人工事件还是自动事件。TRUE为人工事件，FALSE为自动事件；
后两个参数一般设为NULL，在此不作过多说明。
2、BOOL CEvent：：SetEvent();
将CEvent 类对象的状态设置为有信号状态。如果事件是人工事件，则CEvent 类对象保持为有信号状态，直到调用成员函数ResetEvent()将其重新设为无信号状态时为止。如果CEvent 类对象为自动事件，则在SetEvent()将事件设置为有信号状态后，CEvent 类对象由系统自动重置为无信号状态。
如果该函数执行成功，则返回非零值，否则返回零。3、BOOL CEvent：：ResetEvent();
该函数将事件的状态设置为无信号状态，并保持该状态直至SetEvent()被调用时为止。由于自动事件是由系统自动重置，故自动事件不需要调用该函数。如果该函数执行成功，返回非零值，否则返回零。我们一般通过调用WaitForSingleObject函数来监视事件状态。前面我们已经介绍了该函数。由于语言描述的原因，CEvent 类的理解确实有些难度，但您只要通过仔细玩味下面例程，多看几遍就可理解。
C、使用CMutex 类
互斥对象与临界区对象很像.互斥对象与临界区对象的不同在于:互斥对象可以在进程间使用,而临界区对象只能在同一进程的各线程间使用。当然，互斥对象也可以用于同一进程的各个线程间，但是在这种情况下，使用临界区会更节省系统资源，更有效率。
D、使用CSemaphore 类
当需要一个计数器来限制可以使用某个线程的数目时，可以使用“信号量”对象。CSemaphore 类的对象保存了对当前访问某一指定资源的线程的计数值，该计数值是当前还可以使用该资源的线程的数目。如果这个计数达到了零，则所有对这个CSemaphore 类对象所控制的资源的访问尝试都被放入到一个队列中等待，直到超时或计数值不为零时为止。一个线程被释放已访问了被保护的资源时，计数值减1；一个线程完成了对被控共享资源的访问时，计数值增1。这个被CSemaphore 类对象所控制的资源可以同时接受访问的最大线程数在该对象的构建函数中指定。
CSemaphore 类的构造函数原型及参数说明如下：
CSemaphore (LONG lInitialCount=1,
LONG lMaxCount=1,
LPCTSTR pstrName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);
lInitialCount:信号量对象的初始计数值，即可访问线程数目的初始值；
lMaxCount：信号量对象计数值的最大值，该参数决定了同一时刻可访问由信号量保护的资源的线程最大数目；
后两个参数在同一进程中使用一般为NULL，不作过多讨论；
在用CSemaphore 类的构造函数创建信号量对象时要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时，则说明当前占用资源的线程数已经达到了所允许的最大数目，不能再允许其它线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore()函数将当前可用资源数加1。
三、实验方案
本系统通过ＶＣ提供的四种线程同步方案同时实现线程的同步。其架构图如图1-1所示。
图1-1系统结构示意图
通过VC提供的线程创建函数：
CWinThread* AfxBeginThread( AFX_THREADPROC pfnThreadProc, LPVOID pParam, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );
CWinThread*AfxBeginThread(CRuntimeClass* pThreadClass,int nPriority=THREAD_PRIORITY_NORMAL, UINT nStackSize=0,DWORD dwCreateFlags=0, LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
创建多线程，分别通过临界区（CCriticalSection）、事件（CEvent）、互斥量（CMutex）、信号量（CSemaphore）实现同步。
四、实验（设计）仪器设备和材料清单
PC每人一台，windows2000操作系统，Vc++ 6.0,msdn
五、调试及结果测试
在本实验中由于实验简单很容易就调试通过。
1.本系统采用ＭＦＣ编程。其运行界面如图1-2所示。分别人事件、互斥量、临界资源、信号量实现线程同步。
图1-2系统运行界面
2.单击SYNCH(同步按钮)会出现先写完Ａ后再写Ｂ。如果单击ASYNCH 按钮（异步按钮）则会出现ＡＢ交错出现这种现象这正在非同步所出现的现象。如图1-3所示。
图1-3系统运行图
3.在事件同步栏中有两个文本框，分别是源文件路径与目的文件路径。这是通过在内存中申请一个内存区通过复制一个文件来体现线程的同步。如图1-4所示是选择源文件。
图1-4选择源文件
4．选择源文件与目的位置后单击ＣＯＰＹ按钮。如图1-5所示已复制完成。
图1-5复制文件
六、实验数据、结果分析
单击同步与非同步按钮，分别出现两种情况，ＡＢ分别出现，ＡＢ交替出现。达到预期的同步效果。
文件复制体现了同步的特征。
七、思考题
1.多线程是同一进程中的，考虑多进程同步问题？
答：进程同步包括进程的互斥和进程的同步两个方面，是操作系统管理共享资源的一种手段。从考试情况来看，许多考生对这部分知识掌握的不好，理解的不透。用ＰＶ操作解决进程同步问题时首先应确定问题是属于进程互斥还是进程同步，或是互斥与同步的混合问题。然后根据共享资源的数量以及使用共享资源的规则正确的定义信号量及其初值。然后决定在不同信号量上应实施的P操作和V操作，用这些P操作和V操作保证并发进程正确地使用共享资源。下面我们就一些考题做一些分析，让考生在分析中理解进程同步，掌握进程同步。
用PV操作实现进程的互斥
用PV操作实现进程的互斥，只要用一个信号量与一组相关临界区联系起来，信号量的初值定义为“1”。每个进程要进入临界区之前调用P操作，测试自己是否可以立即进入临界区；执行完临界区的程序段后，调用V操作表示自己退出临界区。
用PV操作实现进程的同步
用PV操作实现进程的同步时应定义一组信号量，其中每个信号量与一个消息对应，根据各个消息量的物理含意确定初值。进程通过调用P操作来测定自己需要的消息是否到达，通过调用V操作把其它进程需要的消息发送出去。
2.多线程设计的好处和缺点
答：优点：
相对于单线程而言：可以响应多任务的并发操作。多线程取消了主循环和轮流检测机制，一个线程可以暂停而不阻止系统其他的部分的执行，而且当程序中一个线程阻塞时，只有那个被阻塞的线程暂停，所有其他的线程继续执行。
相对于进程而言：它所要求的开销比较小，转换成本较小。所有线程共享同一地址空间，相互协作。彼此之间通信很容易。
缺点：
等待共享资源的时候，运行速度会慢下来。线程管理需要额外的CPU开销。
如果设计得不不合理，程序会变得异常负责。会引发一些不正常的状态，像饥饿(starving)，竞争(racing)，死锁(deadlock)，活锁(livelock)。
不同平台上会有一些不一致。比如我在开发本书例程时发现，在有些平台下竞争很快就出现，但是换了台机器，它根本就不出现。如果你在后者搞开发，然后发布到前者，那可就惨了
八、源代码
// ThreadSynchDlg.h : header file
//
#if !defined(AFX_THREADSYNCHDLG_H__D7C46AAA_1B84_4F00_A24A_D8BD76ECD0 AA__INCLUDED_)
#define
AFX_THREADSYNCHDLG_H__D7C46AAA_1B84_4F00_A24A_D8BD76ECD0AA__INCL UDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CThreadSynchDlg dialog
class CThreadSynchDlg : public CDialog
{
// Construction
public:
int InitCopyRight();
CThreadSynchDlg(CWnd* pParent = NULL); // standard constructor
BOOL bmutex;
BOOL bcritical;
CString sourcename;
CString desname;
CString filename;
HGLOBAL hGlobal;
long readlen,poslen,filelen;
LPVOID pvData;
// Dialog Data
//{{AFX_DATA(CThreadSynchDlg)
enum { IDD = IDD_THREADSYNCH_DIALOG };
CProgressCtrl m_pos;
CEdit m_source;
CEdit m_des;
CEdit m_resultcs;
CEdit m_resultmu;
CEdit m_resultsp;
CEdit m_resultev;
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CThreadSynchDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CThreadSynchDlg)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnBtsynchevent();
afx_msg void OnBtasynchevent();
afx_msg void OnBtsynchmutex();
afx_msg void OnBtasynchmutex();
afx_msg void OnBtsynchcsection();
afx_msg void OnBtasynchcsection();
afx_msg void OnBtbrowss();
afx_msg void OnBtbrowsd();
afx_msg void OnBtsynchsp();
afx_msg void OnBtasynchsp();
afx_msg void OnBtcopy();
afx_msg void OnBtclear();
afx_msg void OnBtexit();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCA TION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif
// !defined(AFX_THREADSYNCHDLG_H__D7C46AAA_1B84_4F00_A24A_D8BD76ECD0A A__INCLUDED_)
// ThreadSynchDlg.cpp : implementation file
//
#include "stdafx.h"
#include "ThreadSynch.h"
#include "ThreadSynchDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#include
HANDLE hSema;
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CThreadSynchDlg dialog
CThreadSynchDlg::CThreadSynchDlg(CWnd* pParent /*=NULL*/)
: CDialog(CThreadSynchDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CThreadSynchDlg)
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CThreadSynchDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CThreadSynchDlg)
DDX_Control(pDX, IDC_PROGRESS, m_pos);
DDX_Control(pDX, IDC_EDIT_SOURCE, m_source);
DDX_Control(pDX, IDC_EDIT_DESTRINSTION, m_des);
DDX_Control(pDX, IDC_EDIT_CSECTION, m_resultcs);
DDX_Control(pDX, IDC_EDITMUTEX, m_resultmu);
DDX_Control(pDX, IDC_EDIT_EVENT, m_resultev);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CThreadSynchDlg, CDialog)
//{{AFX_MSG_MAP(CThreadSynchDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BTSYNCHEVENT, OnBtsynchevent)
ON_BN_CLICKED(IDC_BTASYNCHEVENT, OnBtasynchevent)
ON_BN_CLICKED(IDC_BTSYNCHMUTEX, OnBtsynchmutex)
ON_BN_CLICKED(IDC_BTASYNCHMUTEX, OnBtasynchmutex)
ON_BN_CLICKED(IDC_BTSYNCHCSECTION, OnBtsynchcsection)
ON_BN_CLICKED(IDC_BTASYNCHCSECTION, OnBtasynchcsection) ON_BN_CLICKED(IDC_BTBROWSS, OnBtbrowss)
ON_BN_CLICKED(IDC_BTBROWSD, OnBtbrowsd)
ON_BN_CLICKED(IDC_BTCOPY, OnBtcopy)
ON_BN_CLICKED(IDC_BTCLEAR, OnBtclear)
ON_BN_CLICKED(IDC_BTEXIT, OnBtexit)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CThreadSynchDlg message handlers
BOOL CThreadSynchDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
bmutex=FALSE;
hSema=CreateSemaphore(NULL,1,1,NULL);
m_pos.SetRange(0,100);
m_pos.SetPos(0);
poslen=0;
return TRUE; // return TRUE unless you set the focus to a control
}
void CThreadSynchDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CThreadSynchDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CThreadSynchDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
CEvent cEvent;//事件
static UINT threadev1(LPVOID pParam)
{
CEdit *p=(CEdit*)pParam;
char buf[MAX_PATH];
for(int i=0;i<20;i++)
{
::SendMessage(p->GetSafeHwnd(),WM_GETTEXT,MAX_PATH,(LPARAM)buf);
strcat(buf,"A");
::SendMessage(p->GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
return 0;
}
static UINT threadev2(LPVOID pParam)
{
CEdit *p=(CEdit*)pParam;
char buf[MAX_PATH];
for(int i=0;i<20;i++)
{
::SendMessage(p->GetSafeHwnd(),WM_GETTEXT,MAX_PATH,(LPARAM)buf);
strcat(buf,"B");
::SendMessage(p->GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
return 0;
}
static UINT threadev3(LPVOID pParam)
{
//InitCopyRight();
CEdit *p=(CEdit*)pParam;
char buf[MAX_PATH];
for(int i=0;i<20;i++)
{
::SendMessage(p->GetSafeHwnd(),WM_GETTEXT,MAX_PATH,(LPARAM)buf);
strcat(buf,"A");
::SendMessage(p->GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
cEvent.SetEvent();
return 0;
}
static UINT threadev4(LPVOID pParam)
{
CEdit *p=(CEdit*)pParam;
char buf[MAX_PATH];
cEvent.Lock();
// InitCopyRight();
for(int i=0;i<20;i++)
{
::SendMessage(p->GetSafeHwnd(),WM_GETTEXT,MAX_PATH,(LPARAM)buf);
strcat(buf,"B");
::SendMessage(p->GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
cEvent.SetEvent();
return 0;
}
void CThreadSynchDlg::OnBtsynchevent()
{
InitCopyRight();
AfxBeginThread(threadev1,&m_resultev);
AfxBeginThread(threadev2,&m_resultev);
}
void CThreadSynchDlg::OnBtasynchevent()
{
InitCopyRight();
AfxBeginThread(threadev3,&m_resultev);
AfxBeginThread(threadev4,&m_resultev);
}
CMutex cMutex(FALSE,NULL);//互斥锁
static UINT threadmu1(LPVOID pParam)
{
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
//char buf[MAX_PA TH];
CString str;
if(pdlg->bmutex==TRUE)
cMutex.Lock();
for(int i=0;i<20;i++)
{
pdlg->m_resultmu.GetWindowText(str);
str+="A";
pdlg->m_resultmu.SetWindowText(str);
Sleep(200);
}
cMutex.Unlock();
return 0;
}
static UINT threadmu2(LPVOID pParam)
{
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
CString str;
if(pdlg->bmutex==TRUE)
cMutex.Lock();
for(int i=0;i<20;i++)
{
pdlg->m_resultmu.GetWindowText(str);
str+="B";
pdlg->m_resultmu.SetWindowText(str);
Sleep(200);
}
cMutex.Unlock();
return 0;
}
void CThreadSynchDlg::OnBtsynchmutex()
{
InitCopyRight();
bmutex=true;
AfxBeginThread(threadmu1,this);
AfxBeginThread(threadmu2,this);
}
void CThreadSynchDlg::OnBtasynchmutex()
{
InitCopyRight();
bmutex=false;
AfxBeginThread(threadmu1,this);
AfxBeginThread(threadmu2,this);
}
CRITICAL_SECTION hCritial;//临界资料
static UINT threadcs1(LPVOID pParam)
{
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
CString str;
char buf[MAX_PATH];
if(pdlg->bcritical==TRUE)
EnterCriticalSection(&hCritial);
for(int i=0;i<20;i++)
{
::SendMessage(pdlg->m_resultcs.GetSafeHwnd(),
WM_GETTEXT, sizeof(buf)/sizeof(char), (LPARAM)buf);
strcat(buf,"A");
UINT len=strlen(buf);
buf[len]='\0';
::SendMessage(pdlg->m_resultcs.GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
LeaveCriticalSection(&hCritial);
return 0;
}
static UINT threadcs2(LPVOID pParam)
{
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
CString str;
char buf[MAX_PATH];
if(pdlg->bcritical==TRUE)
EnterCriticalSection(&hCritial);
for(int i=0;i<20;i++)
{
::SendMessage(pdlg->m_resultcs.GetSafeHwnd(),
WM_GETTEXT, sizeof(buf)/sizeof(char), (LPARAM)buf);
strcat(buf,"B");
UINT len=strlen(buf);
buf[len]='\0';
::SendMessage(pdlg->m_resultcs.GetSafeHwnd(),WM_SETTEXT,0,(LPARAM)buf);
Sleep(200);
}
LeaveCriticalSection(&hCritial);
return 0;
}
void CThreadSynchDlg::OnBtsynchcsection()
{
InitCopyRight();
bcritical=true;
InitializeCriticalSection(&hCritial);
AfxBeginThread(threadcs1,this);
AfxBeginThread(threadcs2,this);
}
void CThreadSynchDlg::OnBtasynchcsection()
{
InitCopyRight();
bcritical=false;
AfxBeginThread(threadcs1,this);
AfxBeginThread(threadcs2,this);
}
void CThreadSynchDlg::OnBtbrowss()
{
CFileDialog log(TRUE,"文件","*.*",OFN_HIDEREADONL Y,"FILE(*.*)|*.*||",NULL);
if(log.DoModal()==IDOK)
{
sourcename=log.GetPathName();
filename=log.GetFileName();
m_source.SetWindowText(sourcename);
}
}
void CThreadSynchDlg::OnBtbrowsd()
{
InitCopyRight();
if(sourcename.IsEmpty())
return;
BROWSEINFO bi;
char buffer[MAX_PA TH];
ZeroMemory(buffer,MAX_PATH);
bi.hwndOwner=GetSafeHwnd();
bi.pidlRoot=NULL;
bi.pszDisplayName=buffer;
bi.lpszTitle="选择一个文件夹";
bi.ulFlags=BIF_EDITBOX;
bi.lpfn=NULL;
bi.lParam=0;
bi.iImage=0;
LPITEMIDLIST pList=NULL;
if((pList=SHBrowseForFolder(&bi))!=NULL)
{
char path[MAX_PATH];
ZeroMemory(path,MAX_PA TH);
SHGetPathFromIDList(pList,path);
desname=path;
if(desname.Right(1)!="\\")
desname.Format("%s\\%s",path,filename);
else
desname.Format("%s%s",path,filename);
m_des.SetWindowText(desname);
}
}
static UINT threadsp1(LPVOID pParam)
{
WaitForSingleObject(hSema,INFINITE);
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
CString tmp;tmp=pdlg->sourcename;
CFile* readfile;
// InitCopyRight();
readfile=new CFile(tmp,CFile::modeRead);
readfile->Seek(pdlg->poslen,CFile::begin);
pdlg->readlen=readfile->Read(pdlg->pvData,512);
pdlg->poslen+=pdlg->readlen;
readfile->Close();
delete readfile;
ReleaseSemaphore(hSema,1,NULL);
return 0;
}
static UINT threadsp2(LPVOID pParam)
{
WaitForSingleObject(hSema,INFINITE);
CThreadSynchDlg *pdlg=(CThreadSynchDlg*)pParam;
CFile* writefile;
writefile=new CFile(pdlg->desname,CFile::modeWrite);
writefile->SeekToEnd();
writefile->Write(pdlg->pvData,pdlg->readlen);
writefile->Close();
delete writefile;
ReleaseSemaphore(hSema,1,NULL);
Java网络编程实验报告 （实验六） 学号：姓名： 实验项目名称：多线程教师评分： 一、实验目的 （1）了解线程的概念。 （2）学习简单的多线程编程。 二、预习内容及要求（要求写出预习内容） 1.进程和线程的概念 进程是程序一次动态执行的过程，对应从代码加载、执行到执行结束这样一个完整的过程，也是进程自身从产生、发展到消亡的过程。 线程是比进程更小的执行单元，一个进程在执行过程中，可以产生多个线程。每个线程都有自身的产生、执行和消亡的过程。 2.线程的状态与生命周期 ●新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此 时它已经有了相应的内存空间和其他资源。 ●运行：线程创建之后就具备了运行的条件，一旦轮到它来享用CPU资源时，即JVM将CPU 使用权切换给该线程时，此线程的就可以脱离创建它的主线程独立开始自己的生命周期了(即 run方法执行的过程)。 ●中断：有4种原因的中断，CPU资源从当前线程切换给其他线程、执行了sleep(int millsecond) 方法、执行了wait()方法、进入阻塞状态。 ●死亡：run方法结束。 3.线程的创建 在Java语言中，与线程支持密切相关的是https://www.doczj.com/doc/877797756.html,ng.Thread类和https://www.doczj.com/doc/877797756.html,ng.Runnable接口。Runnable 接口定义很简单，只有一个run方法。任何一个类如果希望自己的实例能够以线程的形式执行，都可以来实现Runnable接口。 继承Thread类和实现Runnable接口，都可以用来创建Thread对象，效果上并没有什么不同。继承Thread类的方法很明显的缺点就是这个类不能再继承其他的类了，而实现Runnable接口不会有这个麻烦。 另外，在继承Thread类的代码中，this其实就是指当前正在运行的线程对象，如果使用实现Runnable 接口的方式，要得到当前正在执行的线程，需要使用Thread.currentThread()方法。 线程创建后仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start （）方法（从父类继承的方法）通知JVM，这样JVM就会知道又有一个新一个线程排队等候切换了。
进程的控制 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new
program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 3 ．实验步骤 （1）gedit创建进程1.c （2）使用gcc 1.c -o 1编译并./1运行程序1.c #include
实验2 并发与调度 2.2 Windows 2000线程同步 (实验估计时间：120分钟) 背景知识 实验目的 工具/准备工作 实验内容与步骤 背景知识 Windows 2000提供的常用对象可分成三类：核心应用服务、线程同步和线程间通讯。其中，开发人员可以使用线程同步对象来协调线程和进程的工作，以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体和信号等。 多线程编程中关键的一步是保护所有的共享资源，工具主要有互锁函数、临界段和互斥体等；另一个实质性部分是协调线程使其完成应用程序的任务，为此，可利用内核中的事件对象和信号。 在进程内或进程间实现线程同步的最方便的方法是使用事件对象，这一组内核对象允许一个线程对其受信状态进行直接控制 (见表4-1) 。 而互斥体则是另一个可命名且安全的内核对象，其主要目的是引导对共享资源的访问。拥有单一访问资源的线程创建互斥体，所有想要访问该资源的线程应该在实际执行操作之前获得互斥体，而在访问结束时立即释放互斥体，以允许下一个等待线程获得互斥体，然后接着进行下去。 与事件对象类似，互斥体容易创建、打开、使用并清除。利用CreateMutex() API 可创建互斥体，创建时还可以指定一个初始的拥有权标志，通过使用这个标志，只有当线程完成了资源的所有的初始化工作时，才允许创建线程释放互斥体。
为了获得互斥体，首先，想要访问调用的线程可使用OpenMutex() API来获得指向对象的句柄；然后，线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时，就表明该线程获得了互斥体的拥有权。当线程获得拥有权时，线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。放弃共享资源时需要在该对象上调用ReleaseMute() API。然后系统负责将互斥体拥有权传递给下一个等待着的线程(由到达时间决定顺序) 。 实验目的 在本实验中，通过对事件和互斥体对象的了解，来加深对Windows 2000线程同步的理解。 1) 回顾系统进程、线程的有关概念，加深对Windows 2000线程的理解。 2) 了解事件和互斥体对象。 3) 通过分析实验程序，了解管理事件对象的API。 4) 了解在进程中如何使用事件对象。 5) 了解在进程中如何使用互斥体对象。 6) 了解父进程创建子进程的程序设计方法。 工具/准备工作 在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备： 1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤 1. 事件对象 2. 互斥体对象 1. 事件对象 清单2-1程序展示了如何在进程间使用事件。父进程启动时，利用CreateEvent() API创建一个命名的、可共享的事件和子进程，然后等待子进程向事件发出信号并终止父进程。在创建时，子进程通过OpenEvent() API打开事件对象，调用SetEvent() API使其转化为已接受信号状态。两个进程在发出信号之后几乎立即终止。 步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令，进入Visual C++窗口。
java多线程实验报告 篇一：西北农林科技大学java多线程实验报告 实验7 多线程 1.实验目的 (1) 掌握Java多线程的概念和实现方法 (2) 掌握Java多线程的同步问题 2.实验内容 任务一：火车售票 假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒买一张票。打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。程序运行结果见左图。 打开Eclipse Tickets.java public class Ticket extends Thread { int ticket =1000; String name =""; public void run(){ while(true){synchronized(name){ if(ticket "第" + Thread.currentThread().getName()+ "售票点卖出了第" + ticket-- + "张票"); } } } }} try{ } catch(InterruptedException e){ }
Thread.sleep(100); Test.java public class Test { } public static void main(String args[]){} Ticket t = new Ticket(); new Thread(t,"1").start(); new Thread(t,"2").start(); new Thread(t,"3").start(); new Thread(t,"4").start(); new Thread(t,"5").start(); new Thread(t,"6").start(); new Thread(t,"7").start(); new Thread(t,"8").start(); new Thread(t,"9").start(); new Thread(t,"10").start(); 任务二：银行存款 假设某家银行，它可接受顾客的汇款，每做一次汇款，便可计算出汇款的总额。现有两个顾客，每人都分3次，每次100元将钱到入。试编写一个程序，模拟实际作业。 程序如下： classCBank { private static int sum=0; public static void add(int n){ inttmp=sum; tmp=tmp+n;// 累加汇款总额 try{ Thread.sleep((int)(10000*Math.random())); //
操作系统 实验报告 哈尔滨工程大学 计算机科学与技术学院
一、实验概述 1. 实验名称 进程的同步 2. 实验目的 ⑴使用EOS的信号量，编程解决生产者 消费者问题，理解进程同步的意义。 ⑵调试跟踪EOS信号量的工作过程，理解进程同步的原理。 ⑶修改EOS的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理。 3. 实验类型 验证+设计 4. 实验内容 ⑴准备实验 ⑵使用EOS的信号量解决生产者－消费者问题 ⑶调试EOS信号量的工作过程 ①创建信号量 ②等待释放信号量 ③等待信号量（不阻塞） ④释放信号量（不唤醒） ⑤等待信号量（阻塞） ⑥释放信号量（唤醒） ⑷修改EOS的信号量算法 二、实验环境 WindowsXP + EOS集成实验环境 三、实验过程 1. 设计思路和流程图
图4-1.整体试验流程图
图4-2.Main 函数流程图、生产者消费、消费者流程图 2. 算法实现 3. 需要解决的问题及解答 (1). 思考在ps/semaphore.c 文件内的PsWaitForSemaphore 和PsReleaseSemaphore 函数中，为什么要使用原子操作？
答：在执行等待信号量和释放信号量的时候，是不允许cpu响应外部中断的，如果此时cpu响应了外部中断，会产生不可预料的结果，无法正常完成原子操作。 (2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。 (3).P143生产者在生产了13号产品后本来要继续生产14号产品，可此时生产者为什么必须等待消费者消费了4号产品后，才能生产14号产品呢？生产者和消费者是怎样使用同步对象来实现该同步过程的呢？ 答：这是因为临界资源的限制。临界资源就像产品仓库，只有“产品仓库”空闲生产者才能生产东西，有权向里面放东西。所以它必须等到消费者，取走产品，“产品空间”（临界资源）空闲时，才继续生产14号产品。 (4). 根据本实验3.3.2节中设置断点和调试的方法，自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞，直到生产者线程生产了24号产品后，消费者线程才被唤醒并继续执行的过程。 答：可以按照下面的步骤进行调试 (1) 删除所有的断点。 (2) 按F5启动调试。OS Lab会首先弹出一个调试异常对话框。 (3) 在调试异常对话框中选择“是”，调试会中断。 (4) 在Consumer函数中等待Full信号量的代码行（第173行）WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。 (5) 在“断点”窗口（按Alt+F9打开）中此断点的名称上点击右键。 (6) 在弹出的快捷菜单中选择“条件”。 (7) 在“断点条件”对话框（按F1获得帮助）的表达式编辑框中，输入表达式“i == 24”。 (8) 点击“断点条件”对话框中的“确定”按钮。 (9) 按F5继续调试。只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。 4. 主要数据结构、实现代码及其说明 修改PsWaitForSemaphore函数 if (Semaphore->Count>0){ Semaphore->Count--; flag=STATUS_SUCCESS; }//如果信号量大于零，说明尚有资源，可以为线程分配 else flag=PspWait(&Semaphore->WaitListHead, Milliseconds); KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。 return flag; }//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待 修改PsReleaseSemaphore函数 if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {
实验八 Java多线程操作 （实验报告） 一、目的 1．掌握Java多线程操作。 二、实验内容 启动线程，线程休眠，线程同步，等待和唤醒 三、实验环境 JDK1.6+dos环境 四、实验原理 通过案例掌握多线程操作。 五、实验步骤 1、设计一个线程操作类，要求可以产生三个线程对象，并可以分 别设置三个线程的休眠时间，如下所示： 线程A，休眠10秒 线程B，休眠20秒 线程C，休眠30秒 2、生产者与消费者问题，生产者生产一台电脑，消费者马上将生 产出的电脑取走。 六、实验小结 1、class MyThread implements Runnable{
String name; int time; public MyThread(String name,int time){ https://www.doczj.com/doc/877797756.html,=name; this.time=time; } public void run(){ try{ Thread.sleep(this.time); } catch(Exception e){ } System.out.println(https://www.doczj.com/doc/877797756.html,+"线程,休眠"+this.time/1000+"秒"); } } public class Demo08{ public static void main(String args[]){ MyThread mt1=new MyThread("线程A",10000); MyThread mt2=new MyThread("线程B",20000); MyThread mt3=new MyThread("线程C",30000);
实验报告 课程名称： Java语言程序设计 姓名: 学号: 班级: 数学与计算机科学学院
数学与计算机科学学院实验报告实验名称：多线程 指导教师：日期：
if (isPrime) count++; } System.out.println(st + "~" + en + "之间共有" + count + "个质数"); } public static void main(String[] args) { UseThread thread1 = new UseThread(2, 1000); UseThread thread2 = new UseThread(1000, 2000); thread1.start(); thread2.start(); } } 第2题代码： public class Experiment14_2 { public static void main(String[] args) { MyThread t1 = new MyThread("T1"); MyThread t2 = new MyThread("T2"); t1.start(); t2.start(); System.out.println("活动线程数：" + Thread.activeCount()); System.out.println("main()运行完毕"); } } class MyThread extends Thread { public MyThread(String s) { super(s); } public void run() { for (int i = 1; i <= 3; i++) { System.out.println(getName() + "第" + i + "次运行"); try { sleep((int) (Math.random() * 100)); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName() + "结束"); } }
多线程同步操作多个窗口 RunApp "notepad.exe" RunApp "notepad.exe" RunApp "notepad.exe" Delay 2000 Dimenv temp_Hwnd temp_Hwnd = 0 Dim str, arr, i str = Plugin.Window.Search("无标题- 记事本") arr = Split(str, "|") For i = 0 To UBound(arr) - 1 temp_Hwnd = Plugin.Window.FindEx(arr(i), 0, "Edit", 0) BeginThread WriteString While temp_Hwnd <> 0'判断多线程已经启动完毕，继续循环下一个。 Delay 500 Wend Next EndScript Function WriteString() Dim str, Hwnd Hwnd = temp_Hwnd temp_Hwnd = 0 Do str = WaitKey If Hwnd <> Plugin.Window.GetKeyFocusWnd Then Call Plugin.Bkgnd.KeyPress(Hwnd, str) End If Loop End Function 多线程多开窗口同步执行与子线程间的数值如何传递： 1.Dimenv IsThread, i 2.Dim arr_Thread() 3.For i = 0 To 2 4. IsThread = False'未启动线程 5. Redim Preserve arr_Thread(i) 6. arr_Thread(i) = BeginThread(EnterThread) 7. While IsThread = False'未启动成功，等待中 8. Delay 500 9. Wend 10. '跳出循环说明 IsThread = True，已经执行到了，循环继续启动下一个 11.Next
操作系统实验报告 课程名称操作系统实验名称进程（线程）的同步与互斥成绩 学生姓名作业君专业软件工程班级、学号 同组者姓名无实验日期2020 一、实验题目:进程（线程）的同步与互斥 二、实验目的： 自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows中基本的同步对象，掌握相关API的使用方法。 3．了解Windows中多线程的并发执行机制，实现进程的同步与互斥 三、实验内容与要求： 1．实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则； 学习了解Windows同步对象及其特性； 熟悉实验环境，掌握相关API的使用方法； 设计程序，实现生产者/消费者进程(线程)的同步与互斥； 四、算法描述（含数据结构定义）或流程图 #include
#define MAX_THREAD_NUM 64 //最大线程数 #define INTE_PER_SEC 1000 //延迟时间的毫秒值 const int SIZE_OF_BUFFER = 10; //缓冲区长度 int ProductID = 0; //产品号 int ConsumeID = 0; //将被消耗的产品号 int in = 0; //产品进缓冲区时的缓冲区下标 int out = 0; //产品出缓冲区时的缓冲区下标 bool running = true; //判断程序能否继续执行的逻辑值 int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列 HANDLE g_hMutex; //公有信号量，用于线程间的互斥HANDLE g_hFullSemaphore; //生产者的私有信号量，当缓冲区满时迫使生产者等待 HANDLE g_hEmptySemaphore; //消费者的私有信号量，当缓冲区空时迫使消费者等待 //定义一个结构体用于存储线程的信息 struct ThreadInfo { int serial; //线程号 char entity; //线程类别(生产者或消费者) double delay; //等待时间 double persist; //操作时间 }; //生产者 void Producer(void* p) { //定义变量用于存储当前线程的信息 DWORD m_delay; DWORD m_persist; int m_serial; //从参数中获得信息 m_serial = ((ThreadInfo*)(p))->serial; m_delay = (DWORD)(((ThreadInfo*)(p))->delay * INTE_PER_SEC); m_persist = (DWORD)(((ThreadInfo*)(p))->persist * INTE_PER_SEC); while (running) { //P操作 cout << "生产者线程 " << m_serial << " 请求生产." << endl; WaitForSingleObject(g_hEmptySemaphore, INFINITE);
线 程实验报告 黄澄宇320070911241 1.分析 （1）问题阐述，描述。 运用线程的方法设计一个ftp面向客户\服务器的网络应用程序，主要包括服务器端和客户端两方面的工作。 （2）问题分析。 针对问题要求，应该能够实现客户端和服务器端的功能。其中服务器端主要对客户端进行监听。客户端向服务器端进行提出请求。 （3）寻找揭发。 TCP\IP服务器端应用程序都是通过JA V A语言中提供的SeverSocket和Socket两个有关网络的类来实现。 SeverSocket类除了建立一个Sever之外，还通过accept()方法提供了随时监听客户端连接请求的功能。 2.设计。 在服务器端指定一个用来等待连接的端口号，在客户端规定一个主机和端口号，从而在客户端和服务器端创建Socket\ServerSocket实例。
现在服务器端生成一个ServerSocket实例的对象，随时监听客户端的连接请求。 当客户端需要连接时，相应的要生成一个Socket实例的对象，并发出连接请求，其在host参数指明该主机名，port参数指明端口号。 服务器端通过accept（）方法接收到客户端的请求后，开辟一个接口与之进行连接，利用输入输出流，按照一定的协议对Socket 进行读写操作。 关闭输入输出流和Socket。 3.实现。 //FTPServer.java import https://www.doczj.com/doc/877797756.html,.*; import java.io.*; import java.util.*; public class FTPServer { public static void main(String args[]) throws Exception { ServerSocket soc=new ServerSocket(5127); System.out.println("FTP Server Started on Port Number "); while(true) {
一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求： 1．子线程输出的线程序号不能重复。 2．全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include
HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果：
实验四同步与互斥 【实验目的和要求】 1、掌握进程（线程）的同步与互斥。 2、掌握生产者消费者问题的实现方法。 3、掌握多线程编程方法。 【实验内容】 实现生产者消费者问题 1、有一个仓库，生产者负责生产产品，并放入仓库，消费者会从仓库中拿走产品(消费)。 2、仓库中每次只能入一个(生产者或消费者)。 3、仓库中可存放产品的数量最多10个,当仓库放满时，生产者不能再放入产品。 4、当仓库空时，消费者不能从中取出产品。 5、生产、消费速度不同。 【实验原理】 1、信号量mutex提供对缓冲池访问的互斥要求并初始化为1，信号量empty和 full分别用来表示空缓冲项和满缓冲项的个数，信号量empty初始化为n，信号量full初始化为0。 2、定义如下结构及数据： 定义缓冲区内的数据类型：typedef int buffer_item; 缓冲区：buffer_item buffer[BUFFER_SIZE];
对缓冲区操作的变量：int in,out; 信号量mutex提供了对缓冲池访问的互斥要求：pthread_mutex_t mutex; 信号量empty和full分别表示空缓冲顶和满缓冲顶的个数：sem_t empty,full; 可以设定生产者的生产速度及消费者的消费速度：int pro_speed,con_speed; 对缓冲区操作的自增函数：#define inc(k) if(k < BUFFER_SIZE) k = k+1;else k=0 3、并定义了如下实现问题的函数模块： 将生产的产品放入缓冲区： int insert_item(buffer_item item) 从缓冲区内移走一个产品： int remove_item(buffer_item *item) 生产者进程：void *producer(void *param) 消费者进程：void *consumer(void *param) 生产者结构进程消费者结构进程 【程序代码】 //sx.c #include
实验五线程 一实验要求 1、理解进程和线程概念； 2、掌握创建、管理和控制Java线程对象的方法； 3、了解并发执行的多线程存在的各种关系 二实验内容 1、使用线程对象或Timer定时器制作数字时钟标签组件，显示当前日期和时间，每秒刷新，将该标签添加到框架窗口。 import java.awt.FlowLayout; import java.text.SimpleDateFormat;//简单日期格式类 import java.util.Locate; import java.util.Timer;//一种工具，线程用其安排以后在后台线程中执行的任务 import java.util.TimerTask; import java.swing.JLabel; public class ShizhongJFrame extends JFrame{ { Public ShizhongJFrame(){ JFrame f=new JFrame（“数字时钟”）; f.setLayout(new FlowLayout()); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setSize(200,70); final JLable lable=new JLable; final SimpleDateFormat format=new SimpleDateFormat(“H:m:s”,Locate.CHINA); f.add(lable); Timer time=new Timer(); time.scheduleAtFixedRate(new TimerTask(){ Public void run(){ Label.setText(format.format(new Date(System.currentTimeMillis()))); } },0,1000); f.setVisible(true); } Public staic void main(String arg[]){ New ShizhogJFrame(); } } 三实验内容中遇到的问题、解决方法和体会。
线程程序设计 一、课题内容和要求 内容：设计和编写一个编写一个指针式时钟程序，应用线程实现时钟的走动。 要求：本实验旨在通过实验，培养学生将JAVA 线程的相关知识点（包括线程调度，线程同步等）有机结合并加以综合应用，在实验中设计多线程程序的能力。 二、设计思路分析 class Clock:一个指针式时钟的主类 class Layout: 添加窗口和时钟组件 class ClockPaint:定义时钟组件 三、概要设计 public class Clock extends JFrame { public static void main(String[] s) ; } class Layout extends JFrame { public Layout(); } class ClockPaint extends JPanel implements Runnable { int x, y, r; int h, m, s; double rad = Math.PI / 180; public ClockPaint(int x, int y, int r); public void paint(Graphics g); public void run(); } 时钟的绘制:
运行时钟: 四、详细设计 import java.awt.*; import javax.swing.*; import java.util.*; public class Clock extends JFrame { public static void main(String[] s) { new Layout(); } } class Layout extends JFrame {// 添加窗口和时钟组件public Layout() { ClockPaint cp = new ClockPaint(20, 20, 70); add(cp);
. 题目用多线程同步方法解决生产者－消费 者问题(Producer-Consumer Problem) 学院计算机科学与技术学院 专业软件工程 班级 姓名 指导教师 年月日
目录 目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16)
课程设计任务书 学生姓名：专业班级： 指导教师：工作单位：计算机科学与技术学院 题目: 用多线程同步方法解决生产者－消费者问题 (Producer-Consumer Problem) 初始条件： 1．操作系统：Linux 2．程序设计语言：C语言 3．有界缓冲区内设有20个存储单元，其初值为0。放入／取出的数据项按增序设定为1－20这20个整型数。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要 求） 1．技术要求： 1）为每个生产者／消费者产生一个线程，设计正确的同步算法 2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者／消费者线程的自定义标识符。 3）生产者和消费者各有两个以上。 4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2．设计说明书内容要求： 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个程序及其运行结果的主机IP地址和目录。） 5）运行结果与运行情况 （提示: （1）有界缓冲区可用数组实现。 （2）编译命令可用：cc -lpthread -o 目标文件名源文件名 （3）多线程编程方法参见附件。） 3. 调试报告： 1)调试记录 2)自我评析和总结 上机时间安排： 18周一~ 五 08：0 － 12：00 指导教师签名：年月日
多线程同步机制 Critical section（临界区）用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是： ·一个局部性对象，不是一个核心对象。 ·快速而有效率。 ·不能够同时有一个以上的critical section被等待。 ·无法侦测是否已被某个线程放弃。 Mutex Mutex是一个核心对象，可以在不同的线程之间实现“排他性占有”，甚至几十那些现成分属不同进程。它是： ·一个核心对象。 ·如果拥有mutex的那个线程结束，则会产生一个“abandoned”错误信息。 ·可以使用Wait…()等待一个mutex。 ·可以具名，因此可以被其他进程开启。 ·只能被拥有它的那个线程释放（released）。 Semaphore Semaphore被用来追踪有限的资源。它是： ·一个核心对象。 ·没有拥有者。 ·可以具名，因此可以被其他进程开启。 ·可以被任何一个线程释放（released）。 Ev ent Object Ev ent object通常使用于overlapped I/O，或用来设计某些自定义的同步对象。它是： ·一个核心对象。 ·完全在程序掌控之下。 ·适用于设计新的同步对象。 · “要求苏醒”的请求并不会被储存起来，可能会遗失掉。 ·可以具名，因此可以被其他进程开启。 Interlocked Variable 如果Interlocked…()函数被使用于所谓的spin-lock，那么他们只是一种同步机制。所谓spin-lock是一种busy loop，被预期在极短时间内执行，所以有最小的额外负担（overhead）。系统核心偶尔会使用他们。除此之外，interlocked variables主要用于引用技术。他们：·允许对4字节的数值有些基本的同步操作，不需动用到critical section或mutex之类。 ·在SMP（Symmetric Multi-Processors）操作系统中亦可有效运作。 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 3、信号量:为控制一个具有有限数量用户资源而设计。 4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。 一临界区 临界区的使用在线程同步中应该算是比较简单，说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子：比如说有一个全局变量（公共资源）两个线程都会对它进行写操作和读操作，如果我们在这里不加以控制，会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上，但是这时切换到线程B，线程B又把全局变量加1然后又切换到线程A，这时候线程A打印的结果就不是程序想要的结果，也就产生了错误。解决的办法就是设置一个区域，让线程A在操纵全局变量的时候进行加锁，线程B如果想操纵这个全局变量就要等待线程A释放这个锁，这个也就是临界区的概念。 二互斥体 windows api中提供了一个互斥体，功能上要比临界区强大。也许你要问，这个东东和临界区有什么区别，为什么强大？它们有以下几点不一致： 1.critical section是局部对象，而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。 2.critical section是快速高效的，而mutex同其相比要慢很多 3.critical section使用围是单一进程中的各个线程，而mutex由于可以有一个名字，因此它是可以应用于不同的进程，当然也可以应用于同一个进程中的不同线程。 4.critical section 无法检测到是否被某一个线程释放，而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子，一个是程序只能运行一个实例，也就是说同一个程序如果已经运行了，就不能再运行了；另一个是关于非常经典的哲学家吃饭问题的例子。 三事件 事件对象的特点是它可以应用在重叠I/O（overlapped I/0）上，比如说socket编程中有两种模型，一种是重叠I/0，一种是完成端口都是可以使用事件同步。它也是核心对象，因此可以被waitforsingleobje这些函数等待；事件可以有名字，因此可以被其他进程开启。 四信号量 semaphore的概念理解起来可能要比mutex还难，我先简单说一下创建信号量的函数，因为我在开始使用的时候没有很快弄清楚，可能现在还有理解不对的地方，如果有错误还是请大侠多多指教。 CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD LONG lInitialCount, // initial count LONG lMaximumCount, // maximum count LPCTSTR lpName // object name )
《操作系统》实验内容 实验二编程实现进程（线程）同步和互斥 1．实验的目的 （1）通过编写程序实现进程同步和互斥，使学生掌握有关进程（线程）同步与互斥的原理，以及解决进程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥等有关的内容。 （2）了解Windows2000/XP中多线程的并发执行机制，线程间的同步和互斥。 （3）学习使用Windows2000/XP中基本的同步对象，掌握相应的API函数。 （4）掌握进程和线程的概念，进程（线程）的控制原语或系统调用的使用。 （5）掌握多道程序设计的基本理论、方法和技术，培养学生多道程序设计的能力。2．实验内容 在Windows XP、Windows 2000等操作系统下，使用的VC、VB、java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。 3．实验要求 （1）经调试后程序能够正常运行。 （2）采用多进程或多线程方式运行，体现了进程（线程）同步和互斥的关系。 （3）程序界面美观。 4．实验步骤 （1）需求分析：了解基本原理，确定程序的基本功能，查找相关资料，画出基本的数据流图； （2）概要设计：确定程序的总体结构、模块关系和总体流程； （3）详细设计：确定模块内部的流程和实现算法； （4）上机编码和调试； （5）运行测试； （6）编写实验报告。 5．实验报告要求 格式符合《实验报告格式》书；书写规范，排版美观，有较强的文字表达能力，能够正确地表达自己的思想，图表符合规范。 6．实验说明 本实验分两次进行，每次要求填写一份实验报告，报告中的实验名分别为：编程实现进程同步和互斥1和编程实现进程同步和互斥2，其他内容依据实验进度具体填写。