㈠ 在linux環境下，對一個設備文件進行多線程讀寫（兩個線程就行），求大神給一個簡單的程序。
配置文件為 conf.txt
測試代碼如下，注意鏈接的時候加上 -lpthread 這個參數
#include <stdio.h>
#include <errno.h> //perror()
#include <pthread.h>
#include <unistd.h> //sleep()
#include <time.h> // time()
#include <stdlib.h> //rand()
#define FD "conf.txt"
typedef void *(*fun)(void *);
struct my_struct
{
unsigned time_to_wait;
int n;
};
void *test_thread(struct my_struct *);
int main (int argc, char const *argv[])
{
FILE *fp = fopen(FD, "r");
if (fp == NULL)
{
perror(FD);
return -1;
}
srand((unsigned)time(NULL)); //初始化隨機種子
int thread_count;
fscanf(fp, "%d", &thread_count);
fclose(fp);
if (thread_count <= 0)
{
printf("線程數<1,退出程序。\n");
return -1;
}
pthread_t *ptid = (pthread_t *)malloc(sizeof(pthread_t) * thread_count); //保存線程ID
int i;
for (i = 0; i < thread_count; i++)
{
int tw = rand() % thread_count + 1; //隨機等待時間
struct my_struct * p = (struct my_struct *)malloc(sizeof(struct my_struct));
if (p == NULL)
{
perror("內存分配錯誤");
goto ERROR;
}
p->time_to_wait = tw;
p->n = i + 1;
int rval = pthread_create(ptid + i, NULL, (fun) test_thread, (void *)(p)); //注意這里的強制轉換（兩個）
if (rval != 0)
{
perror("Thread creation failed");
goto ERROR;
}
//sleep(1); //這句加也可以，不加也可以。最開始的時候加上這個是為了讓兩個線程啟動的時候之間有一定的時間差
}
printf("主線程啟動\n\n");
fflush(stdout);
for (i = 0; i < thread_count; i++)
{
pthread_join(*(ptid + i), NULL); //等待所有線程退出。
}
printf("\n主線程退出\n");
ERROR:
free(ptid);
return 0;
}
void *test_thread(struct my_struct * p) //線程啟動的時候運行的函數
{
printf("第%d個線程啟動，預計運行%d秒\n", p->n, p->time_to_wait);
fflush(stdout);
sleep(p->time_to_wait); //讓線程等待一段時間
printf("第%d個線程結束\n", p->n);
fflush(stdout);
free(p);
return NULL;
}
你的第二個問題我在網路HI回你了～
㈡ linux 多線程把內存中的內容寫入文件怎樣效
普通磁碟單線程4KB每write最快，同時寫多文件的話注意做內存cache到足夠大後順序寫出到單文件，避免頻繁在文件間切換引起磁軌滑動。
㈢ LinuxC/C++多線程(線程池、讀寫鎖和CAS無鎖編程)
Linux C/C++多線程技術中的線程池、讀寫鎖和CAS無鎖編程的關鍵點如下：
線程池： 定義：線程池作為一種優化手段，通過維護一組線程並分配任務，避免頻繁創建和銷毀線程帶來的性能開銷。 目的：確保內核資源有效利用，防止過度調度。 實現要點：需要定義隊列元素類型，包括數據和處理函數指針，運用互斥鎖或信號量保證線程安全，類似生產者消費者模型。
讀寫鎖： 適用場景：適用於大量讀寫並存的場景。 鎖模式：通過區分讀模式和寫模式，允許多個讀線程同時訪問，但寫操作會變成互斥。 鎖機制：當寫許可權被佔用時，讀許可權會被阻塞。這體現了樂觀鎖與悲觀鎖的區別。
CAS編程： 定義：CAS是一種樂觀並發控制策略，基於硬體支持的原子操作。 優勢：避免了悲觀鎖的死鎖風險，通過沖突時重試的方式，雖然增加了調用者處理競爭的負擔，但能優化性能。 應用：無鎖編程通過CAS操作，盡量減少鎖的使用，解決資源分配不均衡等問題。
這些並發技術旨在提高程序性能，優化資源管理，減少鎖競爭帶來的問題，適用於高效並發環境下的伺服器開發和架構設計。
㈣ Linux線程及同步
linux多線程
1.線程概述
線程是一個進程內的基本調度單位，也可以稱為輕量級進程。線程是在共享內存空間中並發的多道執行路徑，它們共享一個進程的資源，如文件描述和信號處理。因此，大大減少了上下文切換的開銷。一個進程可以有多個線程，也就
是有多個線程式控制製表及堆棧寄存器，但卻共享一個用戶地址空間。
2.線程實現
線程創建pthread_create()
所需頭文件#include
<pthread.h>
函數原型int
pthread_create
((pthread_t
*thread,
pthread_attr_t
*attr,
thread：線程標識符
attr：線程屬性設置
start_routine：線程函數的起始地址
arg：傳遞給start_routine的參數
函數返回值
成功：0
出錯：-1
線程退出pthread_exit();
所需頭文件#include
<pthread.h>
函數原型void
pthread_exit(void
*retval)
函數傳入值retval:pthread_exit()調用者線程的返回值，可由其他函數如pthread_join
來檢索獲取
等待線程退出並釋放資源pthread_join()
所需頭文件#include
<pthread.h>
函數原型int
pthread_join
((pthread_t
th,
void
**thread_return))
函數傳入值
th：等待線程的標識符
thread_return：用戶定義的指針，用來存儲被等待線程的返回值（不為NULL時）
函數返回值
成功：0
出錯：-1
代碼舉例
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
/*線程1*/
6.
void
thread1()
7.
{
8.
int
i=0;
9.
10.
while(1)
11.
{
12.
printf(thread1:%d/n,i);
13.
if(i>3)
14.
pthread_exit(0);
15.
i++;
16.
sleep(1);
17.
}
18.
}
19.
20.
/*線程2*/
21.
void
thread2()
22.
{
23.
int
i=0;
24.
25.
while(1)
26.
{
27.
printf(thread2:%d/n,i);
28.
if(i>5)
29.
pthread_exit(0);
30.
i++;
31.
sleep(1);
32.
}
33.
}
34.
35.
int
main()
36.
{
37.
pthread_t
t1,t2;
38.
39.
/*創建線程*/
40.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
41.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
42.
/*等待線程退出*/
43.
pthread_join(t1,NULL);
44.
pthread_join(t2,NULL);
45.
return
0;
46.
}
3同步與互斥
<1>互斥鎖
互斥鎖的操作主要包括以下幾個步驟。
•
互斥鎖初始化：pthread_mutex_init
•
互斥鎖上鎖：pthread_mutex_lock
•
互斥鎖判斷上鎖：pthread_mutex_trylock
•
互斥鎖接鎖：pthread_mutex_unlock
•
消除互斥鎖：pthread_mutex_destroy
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;/*共享變數*/
6.
pthread_mutex_t
mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥鎖*/
7.
8.
void
thread1()
9.
{
10.
int
ret;
11.
while(1)
12.
{
13.
14.
15.
ret=pthread_mutex_trylock(&mutex);/*判斷上鎖*/
16.
17.
if(ret!=EBUSY)
18.
{
19.
pthread_mutex_lock(&mutex);/*上鎖*/
20.
printf(This
is
thread1:%d/n,i);
21.
i++;
22.
pthread_mutex_unlock(&mutex);/*解鎖*/
23.
}
24.
sleep(1);
25.
}
26.
}
27.
28.
void
thread2()
29.
{int
ret;
30.
while(1)
31.
{
32.
33.
ret=pthread_mutex_trylock(&mutex);
34.
if(ret!=EBUSY)
35.
{
36.
pthread_mutex_lock(&mutex);
37.
printf(This
is
thread2:%d/n,i);
38.
i++;
39.
pthread_mutex_unlock(&mutex);
40.
}
41.
sleep(1);
42.
}
43.
}
44.
int
main()
45.
{
46.
pthread_t
t1,t2;
47.
pthread_mutex_init(&mutex,NULL);
48.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
49.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
50.
51.
pthread_join(t1,NULL);
52.
pthread_join(t2,NULL);
53.
54.
pthread_mutex_destroy(&mutex);
55.
return
0;
56.
}
<2>信號量
未進行同步處理的兩個線程
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;
6.
void
thread1()
7.
{
8.
9.
while(1)
10.
{
11.
printf(This
is
thread1:%d/n,i);
12.
i++;
13.
sleep(1);
14.
}
15.
}
16.
17.
18.
void
thread2()
19.
{
20.
21.
while(1)
22.
{
23.
printf(This
is
thread2:%d/n,i);
24.
i++;
25.
sleep(1);
26.
}
27.
}
28.
29.
int
main()
30.
{
31.
pthread_t
t1,t2;
32.
33.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
34.
pthread_create(&t2,NULL,(void
*)thread2,NULL);