未分类 | 第七根弦的技术博客

首页 › 分类存档 › 未分类

(C语言)多进程实现消费者生产者pv操作(Windows和Linux版本)

第七根弦 2019 年 10 月 12 日 Visual Studio, 未分类, 进程间通信 0

多进程实现消费者生产者问题

一，实验目的
1，了解生产者消费者的互斥与同步问题
2，掌握Windows和Linux的进程通信方法

二，实验要求
完成Windows版本和Linux版本。
一个大小为3的缓冲区，初始为空。
2个生产者
随机等待一段时间，往缓冲区添加数据，
若缓冲区已满，等待消费者取走数据后再添加
重复6次

3个消费者
随机等待一段时间，从缓冲区读取数据
若缓冲区为空，等待生产者添加数据后再读取
重复4次

显示每次添加和读取数据的时间及缓冲区的状态

三，实验环境
Windows版本：Windows 10 64位系统，Dev-cpp编译器
Linux版本：Fedora29版本，gcc环境 vim文本编辑器

四，实验代码结构
1),pv操作伪代码：
array[3]:interger//缓冲区定义,大小为三
int empty=3,full=0;
int mutex=1;
i=0,j=0//缓冲区指针
x，y：item //产品变量
生产者：消费者：
begin：
produce a product to x;
P(empty);
P(mutex);
array[i]=x;
ii=(i+1)%3;
V(full);
V(mutex);
,,,,,, ………,
End

消费者：

2）实验代码分析

Windows版本：

思路分析：Windows创建多进程使用creatprocess()函数调用自己，通过多次创建得到两个生产者进程三个消费者进程，在之中运行相应的生产者函数，消费者函数。在通过传入参数不同，来辨别是第一次主进程还是生产者进程，消费者进程。通过构建共享内存区进行进程间通信。

①多进程创建

② 构建共享内存区，再将文件映射到本进程，初始化

③在主创建进程间信号量full empty

分别在生产者消费者进程创建互斥访问量mutex

④同过argv量的不同判断进程归属

⑤运行结果：

全部代码见后

Linux版本：

思路分析：Linux使用fork进行多进程创建，分别在进程中运行消费者函数，生产者函数。建立共享主存区很信号量在进程建进行通信和缓存访问

②建立共享主存并进行映射

③创建进程间信号量full，empty和互斥量 mutex，并初始化

④实验结果：

五，实验总结

本次实验获得圆满成功。

本次实验通过分别编写Windows和Linux版本的多进程实现消费者和生产者问题，了解生产者消费者的互斥与同步问题，掌握Windows和Linux的进程通信方法，也同时加强自己对多进程操作的理解。

代码：
Windows版本：

//实验三生产者消费者 
#include <windows.h>
#include <stdio.h>
#include <time.h>


HANDLE handleOfProcess[5];

struct buf
{
    char buffer[3];
    int write;
    int read;
};

int rand_1()
{
    return rand() % 100 + 1000;
}

char rand_char()
{
    return rand() % 26 + 'A';
}

void StartClone(int nCloneID)
{
    TCHAR szFilename[MAX_PATH];
    GetModuleFileName(NULL, szFilename, MAX_PATH);

    TCHAR szCmdLine[MAX_PATH];
    sprintf(szCmdLine, "\"%s\" %d", szFilename, nCloneID);
    //printf("%s\n",szCmdLine);

    STARTUPINFO si;
    ZeroMemory(reinterpret_cast<void*>(&si), sizeof(si));

    si.cb = sizeof(si);
    PROCESS_INFORMATION pi;

    BOOL bCreateOK = CreateProcess(
        szFilename,
        szCmdLine,
        NULL,
        NULL,
        FALSE,
        CREATE_DEFAULT_ERROR_MODE,
        NULL,
        NULL,
        &si,
        &pi);
    if (bCreateOK)
        handleOfProcess[nCloneID] = pi.hProcess;
    else
    {
        printf("Error in create process!\n");
        exit(0);
    }
}

void pro()//生产者
{
    HANDLE mutex = CreateMutex(NULL, FALSE, "MYMUTEX");
    HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYEMPTY");
    HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYFULL");

    HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "myfilemap");
    LPVOID Data = MapViewOfFile(//文件映射
        hMap,
        FILE_MAP_ALL_ACCESS,
        0,
        0,
        0);
    struct buf* pint = reinterpret_cast<struct buf*>(Data);

    for (int i = 0; i < 6; i++)
    {
        WaitForSingleObject(empty, INFINITE);
        //sleep
        srand((unsigned)time(0));
        int tim = rand_1();
        Sleep(tim);

        WaitForSingleObject(mutex, INFINITE);

        //code
        pint->buffer[pint->write] = rand_char();
        pint->write = (pint->write + 1) % 3;


        ReleaseMutex(mutex);
        ReleaseSemaphore(full, 1, NULL);

        SYSTEMTIME syst;
        time_t t = time(0);
        GetSystemTime(&syst);
        char tmpBuf[10];
        strftime(tmpBuf, 10, "%H:%M:%S", localtime(&t));
        printf("生产者%d向缓冲区写入数据:\t%c\t%c\t%c\t@%s.%d\n",
            (int)GetCurrentProcessId(), pint->buffer[0], pint->buffer[1],
            pint->buffer[2], tmpBuf, syst.wMilliseconds);
        fflush(stdout);
    }
    UnmapViewOfFile(Data);//解除映射
    Data = NULL;
    CloseHandle(mutex);
    CloseHandle(empty);
    CloseHandle(full);
}

void con()//消费者
{
    HANDLE mutex = CreateMutex(NULL, FALSE, "MYMUTEX");
    HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYEMPTY");
    HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYFULL");

    HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "myfilemap");
    LPVOID Data = MapViewOfFile(//文件映射
        hMap,
        FILE_MAP_ALL_ACCESS,
        0,
        0,
        0);
    struct buf* pint = reinterpret_cast<struct buf*>(Data);

    for (int i = 0; i < 4; i++)
    {
        WaitForSingleObject(full, INFINITE);
        //sleep
        srand((unsigned)time(0));
        int tim = rand_1();
        Sleep(tim);

        WaitForSingleObject(mutex, INFINITE);

        pint->buffer[pint->read] = ' ';
        pint->read = (pint->read + 1) % 3;

        ReleaseMutex(mutex);
        ReleaseSemaphore(empty, 1, NULL);
        //code

        time_t t = time(0);
        char tmpBuf[10];
        SYSTEMTIME syst;
        GetSystemTime(&syst);
        strftime(tmpBuf, 10, "%H:%M:%S", localtime(&t));

        printf("消费者%d从缓冲区读取数据:\t%c\t%c\t%c\t@%s.%d\n",
            (int)GetCurrentProcessId(), pint->buffer[0], pint->buffer[1],
            pint->buffer[2], tmpBuf, syst.wMilliseconds);
        fflush(stdout);

    }
    UnmapViewOfFile(Data);//解除映射
    Data = NULL;
    CloseHandle(mutex);
    CloseHandle(empty);
    CloseHandle(full);
}

int main(int argc, char* argv[])
{
    int nCloneID = 20;
    if (argc > 1)
    {
        sscanf(argv[1], "%d", &nCloneID);
    }

    if (nCloneID < 2)//生产者进程
    {
        pro();
    }
    else if (nCloneID < 5)//消费者进程
    {
        con();
    }
    else//主进程
    {
        HANDLE hMap = CreateFileMapping(
            NULL,
            NULL,
            PAGE_READWRITE,
            0,
            sizeof(struct buf),
            "myfilemap");

        if (hMap != INVALID_HANDLE_VALUE)
        {
            LPVOID Data = MapViewOfFile(//文件映射
                hMap,
                FILE_MAP_ALL_ACCESS,
                0,
                0,
                0);

            if (Data != NULL)
            {
                ZeroMemory(Data, sizeof(struct buf));
            }
            struct buf* pnData = reinterpret_cast<struct buf*>(Data);
            pnData->read = 0;
            pnData->write = 0;
            memset(pnData->buffer, 0, sizeof(pnData->buffer));
            UnmapViewOfFile(Data);//解除映射
            Data = NULL;
        }

        HANDLE empty = CreateSemaphore(NULL, 3, 3, "MYEMPTY");
        HANDLE full = CreateSemaphore(NULL, 0, 3, "MYFULL");
        for (int i = 0; i < 5; i++)//创建子进程
            StartClone(i);
        WaitForMultipleObjects(5, handleOfProcess, TRUE, INFINITE);
        CloseHandle(empty);
        CloseHandle(full);
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

//实验三生产者消费者

#include <windows.h>

#include <stdio.h>

#include <time.h>

HANDLE handleOfProcess[5];

struct buf

{

char buffer[3];

int write;

int read;

};

int rand_1()

{

return rand() % 100 + 1000;

}

char rand_char()

{

return rand() % 26 + 'A';

}

void StartClone(int nCloneID)

{

TCHAR szFilename[MAX_PATH];

GetModuleFileName(NULL, szFilename, MAX_PATH);

TCHAR szCmdLine[MAX_PATH];

sprintf(szCmdLine, "\"%s\" %d", szFilename, nCloneID);

//printf("%s\n",szCmdLine);

STARTUPINFO si;

ZeroMemory(reinterpret_cast<void*>(&si), sizeof(si));

si.cb = sizeof(si);

PROCESS_INFORMATION pi;

BOOL bCreateOK = CreateProcess(

szFilename,

szCmdLine,

NULL,

FALSE,

CREATE_DEFAULT_ERROR_MODE,

NULL,

&si,

&pi);

if (bCreateOK)

handleOfProcess[nCloneID] = pi.hProcess;

else

{

printf("Error in create process!\n");

exit(0);

}

void pro()//生产者

{

HANDLE mutex = CreateMutex(NULL, FALSE, "MYMUTEX");

HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYEMPTY");

HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYFULL");

HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "myfilemap");

LPVOID Data = MapViewOfFile(//文件映射

hMap,

FILE_MAP_ALL_ACCESS,

0);

struct buf* pint = reinterpret_cast<struct buf*>(Data);

for (int i = 0; i < 6; i++)

{

WaitForSingleObject(empty, INFINITE);

//sleep

srand((unsigned)time(0));

int tim = rand_1();

Sleep(tim);

WaitForSingleObject(mutex, INFINITE);

//code

pint->buffer[pint->write] = rand_char();

pint->write = (pint->write + 1) % 3;

ReleaseMutex(mutex);

ReleaseSemaphore(full, 1, NULL);

SYSTEMTIME syst;

time_t t = time(0);

GetSystemTime(&syst);

char tmpBuf[10];

strftime(tmpBuf, 10, "%H:%M:%S", localtime(&t));

printf("生产者%d向缓冲区写入数据:\t%c\t%c\t%c\t@%s.%d\n",

(int)GetCurrentProcessId(), pint->buffer[0], pint->buffer[1],

pint->buffer[2], tmpBuf, syst.wMilliseconds);

fflush(stdout);

}

UnmapViewOfFile(Data);//解除映射

Data = NULL;

CloseHandle(mutex);

CloseHandle(empty);

CloseHandle(full);

}

void con()//消费者

{

HANDLE mutex = CreateMutex(NULL, FALSE, "MYMUTEX");

HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYEMPTY");

HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "MYFULL");

HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "myfilemap");

LPVOID Data = MapViewOfFile(//文件映射

hMap,

FILE_MAP_ALL_ACCESS,

0);

struct buf* pint = reinterpret_cast<struct buf*>(Data);

for (int i = 0; i < 4; i++)

{

WaitForSingleObject(full, INFINITE);

//sleep

srand((unsigned)time(0));

int tim = rand_1();

Sleep(tim);

WaitForSingleObject(mutex, INFINITE);

pint->buffer[pint->read] = ' ';

pint->read = (pint->read + 1) % 3;

ReleaseMutex(mutex);

ReleaseSemaphore(empty, 1, NULL);

//code

time_t t = time(0);

char tmpBuf[10];

SYSTEMTIME syst;

GetSystemTime(&syst);

strftime(tmpBuf, 10, "%H:%M:%S", localtime(&t));

printf("消费者%d从缓冲区读取数据:\t%c\t%c\t%c\t@%s.%d\n",

(int)GetCurrentProcessId(), pint->buffer[0], pint->buffer[1],

pint->buffer[2], tmpBuf, syst.wMilliseconds);

fflush(stdout);

}

UnmapViewOfFile(Data);//解除映射

Data = NULL;

CloseHandle(mutex);

CloseHandle(empty);

CloseHandle(full);

}

int main(int argc, char* argv[])

{

int nCloneID = 20;

if (argc > 1)

{

sscanf(argv[1], "%d", &nCloneID);

}

if (nCloneID < 2)//生产者进程

{

pro();

}

else if (nCloneID < 5)//消费者进程

{

con();

}

else//主进程

{

HANDLE hMap = CreateFileMapping(

NULL,

PAGE_READWRITE,

sizeof(struct buf),

"myfilemap");

if (hMap != INVALID_HANDLE_VALUE)

{

LPVOID Data = MapViewOfFile(//文件映射

hMap,

FILE_MAP_ALL_ACCESS,

0);

if (Data != NULL)

{

ZeroMemory(Data, sizeof(struct buf));

}

struct buf* pnData = reinterpret_cast<struct buf*>(Data);

pnData->read = 0;

pnData->write = 0;

memset(pnData->buffer, 0, sizeof(pnData->buffer));

UnmapViewOfFile(Data);//解除映射

Data = NULL;

}

HANDLE empty = CreateSemaphore(NULL, 3, 3, "MYEMPTY");

HANDLE full = CreateSemaphore(NULL, 0, 3, "MYFULL");

for (int i = 0; i < 5; i++)//创建子进程

StartClone(i);

WaitForMultipleObjects(5, handleOfProcess, TRUE, INFINITE);

CloseHandle(empty);

CloseHandle(full);

}

Linux版本:

//实验三：生产者消费者                                                                                                                                                                                             
#include<string.h>
#include <sys/time.h>
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/sem.h>
#include<sys/select.h>
#include<sys/wait.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<time.h>
#define SEM_ID1 225
#define SEM_ID2 97
#define SEM_ID3 234
#define SHMKEY 75

struct buf {
    char buffer[3];
    int read;
    int write;
};

int rand_1()
{
    return rand() % 300;
}

void sleep_ms(int s)
{
    usleep(s * 10000);
}

char* cur_time()
{
    time_t timep;
    time(&timep);
    return ctime(&timep);
}
char rand_char()
{
    return rand() % 26 + 'A';
}
void P(int s)//p操作 
{
    struct sembuf sem_op;
    sem_op.sem_num = 0;
    sem_op.sem_op = -1;
    sem_op.sem_flg = 0;
    semop(s, &sem_op, 1);
}
void V(int s)//v操作 
{
    struct sembuf sem_op;
    sem_op.sem_num = 0;
    sem_op.sem_op = 1;
    sem_op.sem_flg = 0;
    semop(s, &sem_op, 1);

}
void pro()//生产者
{
    int tim, shmid, i = 6;
    int sem_mutex, sem_empty, sem_full;
    void* addr;
    struct buf* pint;
    struct sembuf sem_op;
    struct timeval tv;
    sem_mutex = semget(SEM_ID1, 1, 0600);
    sem_empty = semget(SEM_ID2, 1, 0600);
    sem_full = semget(SEM_ID3, 1, 0600);
    shmid = shmget(SHMKEY, sizeof(struct buf), 0777);
    addr = shmat(shmid, 0, 0);
    while (i--)
    {
        gettimeofday(&tv, NULL);
        srand((unsigned)tv.tv_usec);
        tim = rand_1();
        sleep_ms(tim);
        //P(empty)
        P(sem_empty);
        //P(mutex)
        P(sem_mutex);

        pint = (struct buf*)addr;

        // pint[semctl(sem_full,0,GETVAL)]=time;
        pint->buffer[pint->write] = rand_char();
        pint->write = (pint->write + 1) % 3;

        printf("当前生产者进程:%d 写入数据:\t%c\t%c\t%c\t@%lds%ldus\n",
            getpid(), pint->buffer[0], pint->buffer[1],
            pint->buffer[2], tv.tv_sec, tv.tv_usec);


        //V(mutex)
        V(sem_mutex);
        //V(full)
        V(sem_full);
    }
    shmdt(addr);
}
void con()//消费者
{
    int tim, shmid, i = 4;
    int sem_mutex, sem_empty, sem_full;
    void* addr;
    struct buf* pint;
    struct sembuf sem_op;
    struct timeval tv;
    sem_mutex = semget(SEM_ID1, 1, 0600);
    sem_empty = semget(SEM_ID2, 1, 0600);
    sem_full = semget(SEM_ID3, 1, 0600);
    shmid = shmget(SHMKEY, sizeof(struct buf), 0777);
    addr = shmat(shmid, 0, 0);
    while (i--)
    {
        gettimeofday(&tv, NULL);
        srand((unsigned)tv.tv_usec);
        tim = rand_1();
        sleep_ms(tim);
        //P(full)
        P(sem_full);
        //P(mutex)
        P(sem_mutex);

        pint = (struct buf*)addr;

        pint->buffer[pint->read] = ' ';
        pint->read = (pint->read + 1) % 3;

        printf("当前消费者进程:%d 读取数据:\t%c\t%c\t%c\t@%ldst%ldms\n",
            getpid(), pint->buffer[0], pint->buffer[1],
            pint->buffer[2], tv.tv_sec, tv.tv_usec);

        //V(mutex)
        V(sem_mutex);
        //V(empty)
        V(sem_empty);

    }
    shmdt(addr);
}

int main()
{
    int sem_mutex, sem_empty, sem_full, shmid;
    void* addr;
    union semun {
        int val;
    }empty, full, mutex;

    //建立信号量 
    sem_mutex = semget(SEM_ID1, 1, IPC_CREAT | 0600);
    sem_empty = semget(SEM_ID2, 1, IPC_CREAT | 0600);
    sem_full = semget(SEM_ID3, 1, IPC_CREAT | 0600);

    full.val = 0;
    empty.val = 3;
    mutex.val = 1;

    semctl(sem_mutex, 0, SETVAL, mutex);
    semctl(sem_empty, 0, SETVAL, empty);
    semctl(sem_full, 0, SETVAL, full);

    //建立共享内存并进行映射 
    shmid = shmget(SHMKEY, sizeof(struct buf), 0777 | IPC_CREAT);
    if (-1 == shmid)
    {
        printf("建立共享内存失败\n");
        exit(0);
    }
    addr = shmat(shmid, 0, 0);
    memset(addr, 0, sizeof(struct buf));

    //执行生产者进程 
    for (int i = 0; i < 2; i++)
        if (fork() == 0)
        {
            pro();
            exit(0);
        }
    //执行消费者进程 
    for (int i = 0; i < 3; i++)
        if (fork() == 0)
        {
            con();
            exit(0);
        }

    while (-1 != wait(0));
    semctl(sem_mutex, 0, IPC_RMID);
    semctl(sem_empty, 0, IPC_RMID);
    semctl(sem_full, 0, IPC_RMID);
    shmdt(addr);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

//实验三：生产者消费者

#include<string.h>

#include <sys/time.h>

#include<stdio.h>

#include<sys/types.h>

#include<unistd.h>

#include<stdlib.h>

#include<sys/sem.h>

#include<sys/select.h>

#include<sys/wait.h>

#include<sys/ipc.h>

#include<sys/shm.h>

#include<time.h>

#define SEM_ID1 225

#define SEM_ID2 97

#define SEM_ID3 234

#define SHMKEY 75

struct buf {

char buffer[3];

int read;

int write;

};

int rand_1()

{

return rand() % 300;

}

void sleep_ms(int s)

{

usleep(s * 10000);

}

char* cur_time()

{

time_t timep;

time(&timep);

return ctime(&timep);

}

char rand_char()

{

return rand() % 26 + 'A';

}

void P(int s)//p操作

{

struct sembuf sem_op;

sem_op.sem_num = 0;

sem_op.sem_op = -1;

sem_op.sem_flg = 0;

semop(s, &sem_op, 1);

}

void V(int s)//v操作

{

struct sembuf sem_op;

sem_op.sem_num = 0;

sem_op.sem_op = 1;

sem_op.sem_flg = 0;

semop(s, &sem_op, 1);

}

void pro()//生产者

{

int tim, shmid, i = 6;

int sem_mutex, sem_empty, sem_full;

void* addr;

struct buf* pint;

struct sembuf sem_op;

struct timeval tv;

sem_mutex = semget(SEM_ID1, 1, 0600);

sem_empty = semget(SEM_ID2, 1, 0600);

sem_full = semget(SEM_ID3, 1, 0600);

shmid = shmget(SHMKEY, sizeof(struct buf), 0777);

addr = shmat(shmid, 0, 0);

while (i--)

{

gettimeofday(&tv, NULL);

srand((unsigned)tv.tv_usec);

tim = rand_1();

sleep_ms(tim);

//P(empty)

P(sem_empty);

//P(mutex)

P(sem_mutex);

pint = (struct buf*)addr;

// pint[semctl(sem_full,0,GETVAL)]=time;

pint->buffer[pint->write] = rand_char();

pint->write = (pint->write + 1) % 3;

printf("当前生产者进程:%d 写入数据:\t%c\t%c\t%c\t@%lds%ldus\n",

getpid(), pint->buffer[0], pint->buffer[1],

pint->buffer[2], tv.tv_sec, tv.tv_usec);

//V(mutex)

V(sem_mutex);

//V(full)

V(sem_full);

}

shmdt(addr);

}

void con()//消费者

{

int tim, shmid, i = 4;

int sem_mutex, sem_empty, sem_full;

void* addr;

struct buf* pint;

struct sembuf sem_op;

struct timeval tv;

sem_mutex = semget(SEM_ID1, 1, 0600);

sem_empty = semget(SEM_ID2, 1, 0600);

sem_full = semget(SEM_ID3, 1, 0600);

shmid = shmget(SHMKEY, sizeof(struct buf), 0777);

addr = shmat(shmid, 0, 0);

while (i--)

{

gettimeofday(&tv, NULL);

srand((unsigned)tv.tv_usec);

tim = rand_1();

sleep_ms(tim);

//P(full)

P(sem_full);

//P(mutex)

P(sem_mutex);

pint = (struct buf*)addr;

pint->buffer[pint->read] = ' ';

pint->read = (pint->read + 1) % 3;

printf("当前消费者进程:%d 读取数据:\t%c\t%c\t%c\t@%ldst%ldms\n",

getpid(), pint->buffer[0], pint->buffer[1],

pint->buffer[2], tv.tv_sec, tv.tv_usec);

//V(mutex)

V(sem_mutex);

//V(empty)

V(sem_empty);

}

shmdt(addr);

}

int main()

{

int sem_mutex, sem_empty, sem_full, shmid;

void* addr;

union semun {

int val;

}empty, full, mutex;

//建立信号量

sem_mutex = semget(SEM_ID1, 1, IPC_CREAT | 0600);

sem_empty = semget(SEM_ID2, 1, IPC_CREAT | 0600);

sem_full = semget(SEM_ID3, 1, IPC_CREAT | 0600);

full.val = 0;

empty.val = 3;

mutex.val = 1;

semctl(sem_mutex, 0, SETVAL, mutex);

semctl(sem_empty, 0, SETVAL, empty);

semctl(sem_full, 0, SETVAL, full);

//建立共享内存并进行映射

shmid = shmget(SHMKEY, sizeof(struct buf), 0777 | IPC_CREAT);

if (-1 == shmid)

{

printf("建立共享内存失败\n");

exit(0);

}

addr = shmat(shmid, 0, 0);

memset(addr, 0, sizeof(struct buf));

//执行生产者进程

for (int i = 0; i < 2; i++)

if (fork() == 0)

{

pro();

exit(0);

}

//执行消费者进程

for (int i = 0; i < 3; i++)

if (fork() == 0)

{

con();

exit(0);

}

while (-1 != wait(0));

semctl(sem_mutex, 0, IPC_RMID);

semctl(sem_empty, 0, IPC_RMID);

semctl(sem_full, 0, IPC_RMID);

shmdt(addr);

}

SSL 认证之后，request.getScheme()获取不到https的问题记录

第七根弦 2019 年 1 月 16 日 nginx, tomcat, 未分类 0

通过浏览器输入https://www.xxx.com，request.getScheme()获取到的确实http而不是https
通过request.getRequestURL()拿到的也是http://www.xxx.com
分析原因，是因为用nginx+tomcat部署web服务，tomcat接受到的请求都是来自于nginx的http请求。

request.getScheme()  //总是 http，而不是实际的http或https  
request.isSecure()  //总是false（因为总是http）  
request.getRemoteAddr()  //总是 nginx 请求的 IP，而不是用户的IP  
request.getRequestURL()  //总是 nginx 请求的URL 而不是用户实际请求的 URL  
response.sendRedirect( 相对url )  //总是重定向到 http 上 （因为认为当前是 http 请求）

request.getScheme() //总是 http，而不是实际的http或https

request.isSecure() //总是false（因为总是http）

request.getRemoteAddr() //总是 nginx 请求的 IP，而不是用户的IP

request.getRequestURL() //总是 nginx 请求的URL 而不是用户实际请求的 URL

response.sendRedirect( 相对url ) //总是重定向到 http 上（因为认为当前是 http 请求）

继续阅读 »

vc++6.0 远程调试

第七根弦 2019 年 1 月 11 日 Visual Studio, 开发环境, 未分类 0

VS2005 vs2008 vs2010 vs2012 远程调试上篇已经讲过，这里再讲下VC++6.0开发环境下的远程调试能力，仅需下面4步即可，更方便的就接着后面的5-6步。

因为目标程序需要在有采集卡等相关硬件支持下的工控机上工作，工控机上面一般没有调试环境也不会放置源代码（出于保密）。假如工控机上的目标程序运行中出了问题，就需要有调试环境却无法安装采集卡等硬件的笔记本上进行远程调试。

一。远程调试条件

１.两者之间使用有线或无线连网。

２.目标机器与本机的调试机器连接通讯，需要四个文件：MSVCMON.EXE、DM.DLL、TLN0T.DLL和MSDIS110.DLL。它们可在VC6安装文件夹的Common/MSDEV98/Bin下面找到。
继续阅读 »

libuv 在win10 vs各个版本编译静态库

第七根弦 2018 年 3 月 12 日未分类 0

01 环境

libuv使用git管理代码，使用gyp管理工程文件。git、python2.x必须。
环境描述：
win10x64企业版本(10.0.14393)，
vs2005–vs2015，
python2.7.6，
git(version 1.9.5.chromium.6)。
git和python建议使用更高版本。
因为下载gyp管理工具需求翻墙，需要vpn。自己有美国的vps，可以自己搭建。
官网：http://libuv.org/
github源码：https://github.com/libuv/libuv

02 源码下载

命令提示符窗口输入：
继续阅读 »

牢记25个最佳的SSH命令

第七根弦 2017 年 12 月 12 日未分类 0

OpenSSH是SSH连接工具的免费版本。telnet，rlogin和ftp用户可能还没意识到他们在互联网上传输的密码是未加密的，但SSH是加密的，OpenSSH加密所有通信（包括密码），有效消除了窃听，连接劫持和其它攻击。此外，OpenSSH提供了安全隧道功能和多种身份验证方法，支持SSH协议的所有版本。

SSH是一个非常伟大的工具，如果你要在互联网上远程连接到服务器，那么SSH无疑是最佳的候选。下面是通过网络投票选出的25个最佳SSH命令，你必须牢记于心。

（注：有些内容较长的命令，在本文中会显示为截断的状态。如果你需要阅读完整的命令，可以把整行复制到您的记事本当中阅读。）
继续阅读 »

Linux抓包和分析

第七根弦 2014 年 9 月 17 日未分类 0

Linux抓包和分析

实践中，通常在 Linux 里用tcpdump命令抓包，然后在Windows 里用wireshark软件分析包。

较通用的tcpdump命令：tcpdump -i eth0 -s 0 -w package.cap

注[对eth0进行完整数据包抓取，数据包输入保存到当前目录package.cap中,因为没有-c参数限制，须按Ctrl+C停止抓包]
继续阅读 »

虚拟机VMWare及VirtualBox虚拟硬盘文件的压缩

第七根弦 2014 年 9 月 12 日未分类 0

在创建虚拟机时，如果选择了动态增长的方式，那么该虚拟机文件其实是“只增不减”，比如你COPY了一个5G的文件进去，那么即使将此文件删除，此虚拟机文件依然不会减小。好在VMware Tools可以在虚拟机中执行Shrink，从而减小其文件大小。

a，进入linux系统，终端下输入：
b，sudo dd if=/dev/zero of=/0bits bs=20971520 # bs=20m
c，sudo rm /0bits
d，然后关闭虚拟机；
e，在windows环境下打开cmd，输入：
f，cd “C:\Program Files\VMware\VMware Workstation” //进入到虚拟机的安装目录
g，vmware-vdiskmanager -k path\to\your\VirtualDisk.vmdkh，//虚拟硬盘压缩完成。

===================================================================
虚拟机使用久了就会发现虚拟硬盘越来越大，但是进入虚拟机里的系统用命令看了下，实际占用的空间远没有虚拟硬盘大小那么大，这个让人很不爽，而且在分享虚拟机镜像的时候也很不方便。VirtualBox似乎没有提供图形界面的方式可以让我们来压缩虚拟硬盘大小，但是可以通过命令行来实现。经过实际测试，我的一个30多G的虚拟硬盘可以压缩到13G大小，可见效果还是非常显著的，这个可以压缩的空间取决于你虚拟机内真实的空间占用大小。

VirtualBox同时支持自己的虚拟硬盘格式VDI和Vmware的VMDK格式，两种格式的压缩略有不同。

1. 碎片整理

第一步要做的是碎片整理，打开虚拟机，执行下面的命令：
Linux系统：

sudo dd if=/dev/zero of=/EMPTY bs=1M
sudo rm -f /EMPTY

1 2	sudo dd if=/dev/zero of=/EMPTY bs=1M sudo rm -f /EMPTY

Windows系统需要下载Sysinternals Suite并执行：

sdelete –z

1	sdelete –z

2. 压缩磁盘

关闭虚拟机，现在可以开始压缩虚拟硬盘了

如果你的虚拟硬盘是VirtualBox自己的VDI格式，找到你的虚拟硬盘文件，执行命令：

VBoxManage modifyhd mydisk.vdi --compact

1	VBoxManage modifyhd mydisk.vdi --compact

如果你的虚拟硬盘是Vmware的VMDK格式，那就要麻烦点，因为VirtualBox不支持直接压缩VMDK格式，但是可以变通下：先转换成VDI并压缩，再转回VMDK。执行命令：

VBoxManage clonehd "source.vmdk" "cloned.vdi" --format vdi
VBoxManage modifyhd cloned.vdi --compact
VBoxManage clonehd "cloned.vdi" "compressed.vmdk" --format vmdk

VBoxManage clonehd "source.vmdk" "cloned.vdi" --format vdi

VBoxManage modifyhd cloned.vdi --compact

VBoxManage clonehd "cloned.vdi" "compressed.vmdk" --format vmdk

事实上，执行命令的过程中可以发现：在从VMDK转换到VDI的过程中似乎已经做了压缩，文件大小已经减少了很多，第二条命令反而没见到文件大小有什么变化，所以这里第二条命令应该可以省略了。

git-svn — 让git和svn协同工作

第七根弦 2014 年 9 月 3 日未分类 0

svn作为一个优秀源码版本的管理工具，可以适合绝大多数项目。但是因为它的采用中心化管理，不可避免的存在本地代码的备份和版本管理问题。也就是说对于尚未或暂无法提交到Subversion服务器的本地代码来说，存在着被误删除和版本更新无法回退两大情形。

继续阅读 »

DuiVision开源界面库介绍

第七根弦 2014 年 8 月 25 日未分类 0

DuiVision是蓝蚂蚁工作室开发的DUI界面库，参考了仿PC管家程序、金山界面库、DuiEngine、DuiLib等多个基于DirectUI的界面库开发的。
继续阅读 »

数字证书原理

第七根弦 2014 年 8 月 15 日未分类 0

文中首先解释了加密解密的一些基础知识和概念，然后通过一个加密通信过程的例子说明了加密算法的作用，以及数字证书的出现所起的作用。接着对数字证书做一个详细的解释，并讨论一下windows中数字证书的管理，最后演示使用makecert生成数字证书。如果发现文中有错误的地方，或者有什么地方说得不够清楚，欢迎指出！

继续阅读 »

第七根弦的技术博客

(C语言)多进程实现消费者生产者pv操作(Windows和Linux版本)

SSL 认证之后，request.getScheme()获取不到https的问题记录

vc++6.0 远程调试

libuv 在win10 vs各个版本编译静态库

01 环境

02 源码下载

牢记25个最佳的SSH命令

Linux抓包和分析

虚拟机VMWare及VirtualBox虚拟硬盘文件的压缩

1. 碎片整理

2. 压缩磁盘

git-svn — 让git和svn协同工作

DuiVision开源界面库介绍

数字证书原理

近期文章

近期评论

归档

分类

其他操作