第七根弦的技术博客

expdp/impdp 数据泵导入导出

第七根弦 2020 年 3 月 2 日 Oracle 0

业务场景：

在工作中，涉及到oracle数据库迁移，使用navicat等其他工具容易报错，一系列问题很麻烦，今天记录一下操作流程及个人理解（文章参考了很多文档和博客）；
EXPDP数据导出

请自行修改目录路径和自定义的表名，否则出现错误很难查找~

一般expdp流程：

一、新建逻辑目录

最好以system等管理员创建逻辑目录，Oracle不会自动创建实际的物理目录“D:\oracleData”（务必手动创建此目录），仅仅是进行定义逻辑路径dump_dir；

忘记sys用户密码的可以去下如何修改sys用户密码；

建议使用pl、navicat等oracle操作工具来操作；
继续阅读 »

(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);

}

GPG入门笔记

第七根弦 2019 年 2 月 27 日 gpg, Linux shell 0

0. 简介
GPG 是 GNU Privacy Guard的简写，是GNU对PGP技术的实现。PGP是Pretty Good Privacy的简写，是一套用于加密的软件。
PGP加密过程如下（来自维基百科 PGP）：

PGP同时利用了对称加密和非对称加密，对文件内容的加密用的是对称加密，对称加密的密钥是每次加密时生成的。由于对称密钥要随密文一起传输，采用了非对称加密算法给对称密钥进行了加密。
继续阅读 »

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 请求）

继续阅读 »

解决nginx部署https后，原tomcat部署的javaweb项目http不能正常加载js、css资源问题

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

公司做的小程序项目到部署的时候发现必须要用https协议，这个时候就在阿里云上申请了免费版本的SSL证书，这里证书的申请就不做介绍了，下面直接看怎么处理资源加载问题，从nginx和tomcat的配置文件入手。
1.nginx配置vhost.conf
继续阅读 »

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下面找到。
继续阅读 »

VS2005 vs2008 vs2010 vs2012 远程调试

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

一远程端的设置

1. 远程机器端的安全选项
在远程机器上，开始——设置——控制面板——管理工具——本地安全策略——本地策略——安全选项，在右侧找到网络访问：本地帐户的共享和安全模式，双击它，将“进来宾 – 本地用户以来宾身份验证”，改为：“经典 – 本地用户以自己的身份验证”

2.远程端运行VS 远程调试监视器
将本地文件夹下远程调试监视器所在文件夹（具体位置见后面四。注意事项）下的所有文件，全部复制到远程计算机中，比如到 E:\remote\x86下。这里以vs2005为例，其余只是版本不同，操作都一样。
双击启动其中的msvsmon.exe，在其菜单，工具——选项　中，更改身份验证方式。
2.1 选择无身份验证（仅限本机），并勾选“允许任何用户进行调试”。“服务器名”将显示 tu:4015，其中的tu是远程计算机的名称，4015是端口号。
2.2 选择 Windows身份验证。“服务器名”，将显示 BT\lk@tu，其中，BT 是局域网的域名，lk是登陆的用户名称，tu是远程计算机的名称。如无登录域，则显示为：lk@tu，其中，lk是登陆的用户名称，tu是远程计算机的名称。
继续阅读 »

Codeblocks更改编译器为VC++6.0

第七根弦 2019 年 1 月 11 日 codeblocks, Visual Studio 0

有时C/C++代码在Codeblocks上不能很好的运行，这是由于代码不标准造成的，Codeblocks编译器默认是GNU GCC，GCC遵循C++标准，而VC++是不太一样的。这篇文章介绍在Codeblocks下如何编译、调试VC 6.0的项目。（有错误的话请指正^_^）
条件
1、安装好Codeblocks16.01带MinGW
2、安装好VC++6.0(路径C:\Program Files (x86)\Microsoft Visual Studio)
步骤
1、打开Codeblocks，选择”Settings” – Compiler”,按图中步骤进行，C:\Program Files (x86)\Microsoft Visual Studio\VC98在VC++安装目录内

继续阅读 »

git配置代理命令

第七根弦 2018 年 12 月 12 日 git 0

// 查看当前代理设置

git config --global http.proxy

1	git config --global http.proxy

// 设置当前代理为 http://127.0.0.1:1080 或 socket5://127.0.0.1:1080

git config --global http.proxy 'http://127.0.0.1:1080'
git config --global https.proxy 'http://127.0.0.1:1080'
git config --global http.proxy 'socks5://127.0.0.1:1080'
git config --global https.proxy 'socks5://127.0.0.1:1080'

git config --global http.proxy 'http://127.0.0.1:1080'

git config --global https.proxy 'http://127.0.0.1:1080'

git config --global http.proxy 'socks5://127.0.0.1:1080'

git config --global https.proxy 'socks5://127.0.0.1:1080'

// 删除 proxy git config –global –unset http.proxy

git config --global --unset https.proxy

1	git config --global --unset https.proxy

第七根弦的技术博客

expdp/impdp 数据泵导入导出

宏定义转字符串

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

GPG入门笔记

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

解决nginx部署https后，原tomcat部署的javaweb项目http不能正常加载js、css资源问题

vc++6.0 远程调试

VS2005 vs2008 vs2010 vs2012 远程调试

Codeblocks更改编译器为VC++6.0

git配置代理命令

近期文章

近期评论

归档

分类

其他操作