首页 › 作者存档 › 第七根弦

前言

QT5.13版本后无法使用Mysql。

一、Mysql缺少报错

1.在QT中使用

db = QSqlDatabase::addDatabase("QMYSQL");//加入mysql数据库

1	db = QSqlDatabase::addDatabase("QMYSQL");//加入mysql数据库

2.然后会报以下错误：

QSqlDatabase: QMYSQL driver not loaded QSqlDatabase: available drivers: QSQLITE QODBC QODBC3 QPSQL QPSQL7

1	QSqlDatabase: QMYSQL driver not loaded QSqlDatabase: available drivers: QSQLITE QODBC QODBC3 QPSQL QPSQL7

继续阅读 »

设置无需用户名密码直接可访问、读写：

在配置文件 /etc/samba/smb.conf最后添加如下内容，再重启samba

[upan]
   comment = public path
   path = /upan/download/
   guest ok = yes
   browseable = yes
   writeable = yes
   create mask = 0777
   directory mask = 0777

[upan]

comment = public path

path = /upan/download/

guest ok = yes

browseable = yes

writeable = yes

create mask = 0777

directory mask = 0777

继续阅读 »

Raspberry Pi 树莓派安装64位系统打造全功能NAS [全网最正确操作记录]

第七根弦 2020.12.30 树莓派 0

安装树莓派64位系统

下载树莓派64位系统，我不要桌面所以选择了lite
https://downloads.raspberrypi.org/raspios_lite_arm64/images/raspios_lite_arm64-2020-08-24/2020-08-20-raspios-buster-arm64-lite.zip

用USB Image Tool将镜像写入TF卡（Win32DiskImager只是个垃圾）
用法很简单：插入tf卡，在USB Image Tool左侧选好盘，右侧使用“Restore”将raspios-buster-arm64-lite.img镜像写入tf卡即可。

树莓派开启ssh服务

写入完成后，在资源管理器里会多出一个boot盘符，在boot分区下新建一个空文件，名为ssh，就可以给树莓派开启SSH服务，适合没屏幕操作。

树莓派自动链接wifi

在boot分区下新建wpa_supplicant.conf文件，并写入无线的相关配置。可以同时配置多个无线网络。

country=CN
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="wifi链接名"
    psk="wifi密码"
    key_mgmt=WPA-PSK
}

country=CN

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev

update_config=1

network={

ssid="wifi链接名"

psk="wifi密码"

key_mgmt=WPA-PSK

}

继续阅读 »

Qt5–编译与安装

第七根弦 2020.11.14 QT 0

工欲善其事，必先利其器。学习任何框架，下载安装总是第一步。Qt因为开发源码，所以有直接安装和源码安装两种方式，建议是第一次先直接安装，如果后面需要重新编译特定的模块，或者需要静态库，再额外的编译源码。至于IDE，我推荐使用Qt自带的QtCreator。
继续阅读 »

Qt最新版5.15.1在Win10环境静态编译安装和部署的完整过程(VS2019)

第七根弦 2020.11.09 QT 0

本文本来是记录Qt5.12.2编译部署过程，目前Qt5系列的最后一个LTS版发布，这个版本没有提供离线安装版，要是用必须使用在线安装。这两天编译Qt5.15.1发现编译步骤没有什么变化，所以就改一个标题。

一、为什么要静态编译

用QtCreator编译程序时，使用的是动态编译。编译好的程序在运行时需要另外加上相应的Qt库文件，一大堆dll文件。如果想将生成的程序连同所需要的库一起完整地打包成一个可执行程序，那就需要使用静态编译。Qt官方不提供静态编译好的安装包，所以需要我们在自己的电脑上静态编译。而且exe文件会比动态编译的要小上很多。
继续阅读 »

oracle 利用shell脚本自动执行raman热备（全量和增量）

第七根弦 2020.06.15 未分类 0

1、不废话直接上脚本
vim oracle_rman_bak.sh
#!/bin/sh
source /home/oracle/.bash_profile

if [ -z $1 ]
then
echo “Please Input a number,Usage: 0|1|2”
exit
else
RMAN_LEVEL=$1
fi

export ORACLE_SID=jkdata
export TODAY=date '+%Y%m%d'
export RMAN_DIR=/data/backup/oracledata/rmanbak/$ORACLE_SID/$TODAY-$RMAN_LEVEL
#######
mkdir -p $RMAN_DIR
cd $RMAN_DIR
LogFile=ora_rman_bk_$ORACLE_SID-L$RMAN_LEVEL-date '+%Y%m%d'.log

# rman backup
rman target / msglog=$RMAN_DIR/$LogFile<<EOF
delete noprompt obsolete;
CONFIGURE BACKUP OPTIMIZATION ON;
CONFIGURE CONTROLFILE AUTOBACKUP ON;
CONFIGURE CONTROLFILE AUTOBACKUP FORMAT FOR DEVICE TYPE DISK TO ‘$RMAN_DIR/cf%F’;
run {
allocate channel c1 type disk;
allocate channel c2 type disk;
backup as compressed backupset incremental level $RMAN_LEVEL filesperset 3 tag ‘dbL$RMAN_LEVEL’ format ‘$RMAN_DIR/ora_o_%d_%t_%c%s%p%u’
database skip readonly include current controlfile;
sql ‘alter system archive log current’ ;
backup(archivelog all format ‘$RMAN_DIR/ora_a_%d_%t_%c%s%p%u’ delete input);
release channel c1;
release channel c2;
}

list backup;
exit;
EOF

#mail backup log
mail -s “$ORACLE_SID rman L$RMAN_LEVEL backup log $TODAY” [email protected] <$RMAN_DIR/$LogFile

2、在crontab 中设置如下：
0 4 * * 5 sh /home/oracle/backup_scripts/oracle_rman_bak.sh 0 > /data/backup/oracledata/logs/rman.log 2>&1
0 4 * * 2 sh /home/oracle/backup_scripts/oracle_rman_bak.sh 1 > /data/backup/oracledata/logs/rman.log 2>&1

Auto packing the repository in background for optimum performance

第七根弦 2020.04.01 git 0

git运行突然提示
Auto packing the repository in background for optimum performance

查资料，原来是自己本地一些 “悬空对象”太多(git删除分支或者清空stash的时候，这些其实还没有真正删除，成为悬空对象，我们可以使用merge命令可以从中恢复一些文件)

解决：
1.输入命令：git fsck –lost-found，可以看到好多“dangling commit”
2.清空他们：git gc –prune=now，完成

expdp/impdp 数据泵导入导出

第七根弦 2020.03.02 Oracle 0

业务场景：

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

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

一般expdp流程：

一、新建逻辑目录

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

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

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

宏定义转字符串

第七根弦 2019.11.02 未分类 0

#include <stdio.h>

#define ZERO    "0"
#define ONE     1
#define STR1(R) #R
#define STR2(R) STR1(R)

int main()
{
    printf("%s\n", ZERO);
    printf("%s\n", STR1(ZERO));
    printf("%s\n", STR2(ZERO));
    printf("%s\n", STR1(ONE));
    printf("%s\n", STR2(ONE));
	
	return 0;
}

#include <stdio.h>

#define ZERO "0"

#define ONE 1

#define STR1(R) #R

#define STR2(R) STR1(R)

int main()

{

printf("%s\n", ZERO);

printf("%s\n", STR1(ZERO));

printf("%s\n", STR2(ZERO));

printf("%s\n", STR1(ONE));

printf("%s\n", STR2(ONE));

return 0;

}

输出

0
ZERO
"0"
ONE
1

ZERO

"0"

ONE

(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\[email protected]%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\[email protected]%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\[email protected]%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\[email protected]%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);

}

第七根弦的技术博客

QT5.13之后的版本需要自行编译Mysql的driver

前言

一、Mysql缺少报错

树莓派samba配置文件的一些说明

设置无需用户名密码直接可访问、读写：

Raspberry Pi 树莓派安装64位系统打造全功能NAS [全网最正确操作记录]

安装树莓派64位系统

树莓派开启ssh服务

树莓派自动链接wifi

Qt5–编译与安装

Qt最新版5.15.1在Win10环境静态编译安装和部署的完整过程(VS2019)

一、为什么要静态编译

oracle 利用shell脚本自动执行raman热备（全量和增量）

Auto packing the repository in background for optimum performance

expdp/impdp 数据泵导入导出

宏定义转字符串

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

近期文章

近期评论

文章归档

分类目录

功能