linuxc語言sync

A. sync是什麼

sync（意指Synchronize，即「同步」）為UNIX操作系統的標准系統調用，功能為將內核文件系統緩沖區的所有數據。

sync作為C語言的函數之一，sync()一般以void sync(void)的形式在unistd.h內聲明。該函數也可以從命令行執行sync命令的方式調用，同時在其他程序語言（如Perl）中也有名字與之相似的函數。

UNIX中還有一些與sync相似的系統調用，如fsync與fdatasync。其中fsync負責寫入所有與特定文件描述符相關的緩沖區數據；fdatasync功能與fsync相似，但只負責寫入文件中被變更的數據，而不會修改文件的元數據（如文件屬性）。

sync在資料庫中的應用

在對數據進行修改操作（包括增、刪、改）時，被修改的數據一般僅是暫存於基於內存的寫入緩存，而當掉電時這些修改便會丟失；而為保證數據的持久性，資料庫必須使用某些形式的sync，以確保修改的內容切實寫入非易失性存儲器，如PostgreSQL就使用了多種sync類調用（包括fsync與fdatasync）來達到這一目的。

但是，對於旋轉尋道的硬碟來說，每次旋轉只能完成一項「提交」操作以將客戶端的修改寫入，因此每秒最多隻能完成幾百次的「提交」操作；而若關閉fsync的限定來放寬要求，則可大幅提升性能，但同時也會帶來系統崩潰後資料庫損毀的潛在危險。有鑒於此，資料庫也使用囊括最近修改信息的日誌文件（一般比主題數據文件小得多）來保障可靠性：根據日誌文件，系統管理員可以在系統崩潰後准確地重做修改操作，以此即可減少對主要數據文件的sync操作。

B. 在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題

這個問題需要的知識主要包括：

1 多進程間進行通信；

2 使用同步信號量（semaphore）和互斥信號量（mutex）進行數據保護。

參考代碼如下，可以參照注釋輔助理解：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#defineN2//消費者或者生產者的數目
#defineM10//緩沖數目
intin=0;//生產者放置產品的位置
intout=0;//消費者取產品的位置
intbuff[M]={0};//緩沖初始化為0，開始時沒有產品
sem_tempty_sem;//同步信號量，當滿了時阻止生產者放產品
sem_tfull_sem;//同步信號量，當沒產品時阻止消費者消費
pthread_mutex_tmutex;//互斥信號量，一次只有一個線程訪問緩沖
intproct_id=0;//生產者id
intprochase_id=0;//消費者id
/*列印緩沖情況*/
voidprint()
{
	inti;
	for(i=0;i<M;i++)
	printf("%d",buff[i]);
	printf("
");
}
/*生產者方法*/
void*proct()
{
	intid=++proct_id;

	while(1)
	{
	//用sleep的數量可以調節生產和消費的速度，便於觀察
	sleep(1);
	//sleep(1);
	
	sem_wait(&empty_sem);
	pthread_mutex_lock(&mutex);
	
	in=in%M;
	printf("proct%din%d.like:	",id,in);
	
	buff[in]=1;
	print();
	++in;
	
	pthread_mutex_unlock(&mutex);
	sem_post(&full_sem);
	}
}
/*消費者方法*/
void*prochase()
{
	intid=++prochase_id;
	while(1)
	{
	//用sleep的數量可以調節生產和消費的速度，便於觀察
	sleep(1);
	//sleep(1);
	
	sem_wait(&full_sem);
	pthread_mutex_lock(&mutex);
	
	out=out%M;
	printf("prochase%din%d.like:	",id,out);
	
	buff[out]=0;
	print();
	++out;
	
	pthread_mutex_unlock(&mutex);
	sem_post(&empty_sem);
	}
}
intmain()
{
	pthread_tid1[N];
	pthread_tid2[N];
	inti;
	intret[N];

	//初始化同步信號量
	intini1=sem_init(&empty_sem,0,M);
	intini2=sem_init(&full_sem,0,0);
	if(ini1&&ini2!=0)
	{
	printf("seminitfailed
");
	exit(1);
	}
	//初始化互斥信號量
	intini3=pthread_mutex_init(&mutex,NULL);
	if(ini3!=0)
	{
	printf("mutexinitfailed
");
	exit(1);
	}
	//創建N個生產者線程
	for(i=0;i<N;i++)
	{
	ret[i]=pthread_create(&id1[i],NULL,proct,(void*)(&i));
	if(ret[i]!=0)
	{
	printf("proct%dcreationfailed
",i);
	exit(1);
	}
	}
	//創建N個消費者線程
	for(i=0;i<N;i++)
	{
	ret[i]=pthread_create(&id2[i],NULL,prochase,NULL);
	if(ret[i]!=0)
	{
	printf("prochase%dcreationfailed
",i);
	exit(1);
	}
	}
	//銷毀線程
	for(i=0;i<N;i++)
	{
	pthread_join(id1[i],NULL);
	pthread_join(id2[i],NULL);
	}
	exit(0);
}

在Linux下編譯的時候，要在編譯命令中加入選項-lpthread以包含多線程支持。比如存儲的C文件為demo.c,要生成的可執行文件為demo。可以使用命令：

gcc demo.c -o demo -lpthread

程序中為便於觀察，使用了sleep(1);來暫停運行，所以查看輸出的時候可以看到，輸出是每秒列印一次的。

C. C語言中「sync（）；」是什麼意思

sync是C語言的一個庫函數。調用sync可以將系統緩沖區(內存中)的數據寫入到文件系統(磁碟)中。x0dx0async的聲明為：x0dx0ax0dx0aint sync(void);x0dx0a位於頭文件unistd.h。x0dx0a當同步成功返回0，否則返回-1。x0dx0a功能為將系統緩沖區的內容寫回磁碟，以確保數據同步。x0dx0a在操作系統中，除非設置了自動同步，否則為了減少磁碟的寫入量，延長磁碟壽命，寫入文件時並不是即時寫入到磁碟中，而是先寫入內存，這段內悔念存區域被稱為系統緩沖區。在系統緩沖區數據累計到一定數量後（具體數量因系統實際設置而定）租虛，會有系統進程一次性寫入所有緩沖數據。這樣，如果意外斷碧型困電，那麼系統緩沖區內數據就會因此丟失。於是在寫入一些重要數據時，都會在寫入結束後進行一次sync()的調用，保證數據已經被寫入磁碟，降低數據丟失或損壞的可能性。

D. Linux C 怎麼實現兩個線程同步讀取兩個內存的數據

在Linux系統中使用C/C++進行多線程編程時，我們遇到最多的就是對同一變數的多線程讀寫問題，大多情況下遇到這類問題都是通過鎖機制來處理，但這對程序的性能帶來了很大的影響，當然對於那些系統原生支持原子操作的數據類型來說，我們可以使用原子操作來處理，這能對程序的性能會得到一定的提高。那麼對於那些系統不支持原子操作的自定義數據類型，在不使用鎖的情況下如何做到線程安全呢？本文將從線程局部存儲方面，簡單講解處理這一類線程安全問題的方法。

一、數據類型
在C/C++程序中常存在全局變數、函數內定義的靜態變數以及局部變數，對於局部變數來說，其不存在線程安全問題，因此不在本文討論的范圍之內。全局變數和函數內定義的靜態變數，是同一進程中各個線程都可以訪問的共享變數，因此它們存在多線程讀寫問題。在一個線程中修改了變數中的內容，其他線程都能感知並且能讀取已更改過的內容，這對數據交換來說是非常快捷的，但是由於多線程的存在，對於同一個變數可能存在兩個或兩個以上的線程同時修改變數所在的內存內容，同時又存在多個線程在變數在修改的時去讀取該內存值，如果沒有使用相應的同步機制來保護該內存的話，那麼所讀取到的數據將是不可預知的，甚至可能導致程序崩潰。
如果需要在一個線程內部的各個函數調用都能訪問、但其它線程不能訪問的變數，這就需要新的機制來實現，我們稱之為Static memory local to a thread (線程局部靜態變數)，同時也可稱之為線程特有數據（TSD: Thread-Specific Data）或者線程局部存儲（TLS: Thread-Local Storage）。這一類型的數據，在程序中每個線程都會分別維護一份變數的副本()，並且長期存在於該線程中，對此類變數的操作不影響其他線程。如下圖：

二、一次性初始化
在講解線程特有數據之前，先讓我們來了解一下一次性初始化。多線程程序有時有這樣的需求：不管創建多少個線程，有些數據的初始化只能發生一次。列如：在C++程序中某個類在整個進程的生命周期內只能存在一個實例對象，在多線程的情況下，為了能讓該對象能夠安全的初始化，一次性初始化機制就顯得尤為重要了。——在設計模式中這種實現常常被稱之為單例模式（Singleton）。Linux中提供了如下函數來實現一次性初始化：
#include <pthread.h>

// Returns 0 on success, or a positive error number on error
int pthread_once (pthread_once_t *once_control, void (*init) (void));
利用參數once_control的狀態，函數pthread_once()可以確保無論有多少個線程調用多少次該函數，也只會執行一次由init所指向的由調用者定義的函數。init所指向的函數沒有任何參數，形式如下：
void init (void)
{
// some variables initializtion in here
}
另外，參數once_control必須是pthread_once_t類型變數的指針，指向初始化為PTHRAD_ONCE_INIT的靜態變數。在C++0x以後提供了類似功能的函數std::call_once ()，用法與該函數類似。使用實例請參考https://github.com/ApusApp/Swift/blob/master/swift/base/singleton.hpp實現。

E. 運用c語言在linux系統下減少對程序計算時間，急

不知道你代碼的目的，不好說你要怎樣。
代碼也沒什麼內容，因子的范圍也搞不清楚。
另外你需要移植到什麼平台？
MingW/Windows應該可以直接運行，多核處理器和SpeedStep可能會引起一些麻煩。

F. linux c中sync函數是什麼作用

sync函數只是將所有修改過的塊緩沖區排入寫隊列，它不等待實際寫磁碟操作結束直接返回！

G. c語言實例，linux線程同步的信號量方式 謝謝

這么高的懸賞，實例放後面。信號量(sem),如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。

信號量初始化。
intsem_init(sem_t*sem,intpshared,unsignedintvalue);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
intsem_wait(sem_t*sem);
釋放信號量。信號量值加1。並通知其他等待線程。
intsem_post(sem_t*sem);
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
intsem_destroy(sem_t*sem);

#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#include<errno.h>
#definereturn_if_fail(p)if((p)==0){printf("[%s]:funcerror!/n",__func__);return;}
typedefstruct_PrivInfo
{
sem_ts1;
sem_ts2;
time_tend_time;
}PrivInfo;
staticvoidinfo_init(PrivInfo*thiz);
staticvoidinfo_destroy(PrivInfo*thiz);
staticvoid*pthread_func_1(PrivInfo*thiz);
staticvoid*pthread_func_2(PrivInfo*thiz);
intmain(intargc,char**argv)
{
pthread_tpt_1=0;
pthread_tpt_2=0;
intret=0;
PrivInfo*thiz=NULL;
thiz=(PrivInfo*)malloc(sizeof(PrivInfo));
if(thiz==NULL)
{
printf("[%s]:Failedtomallocpriv./n");
return-1;
}
info_init(thiz);
ret=pthread_create(&pt_1,NULL,(void*)pthread_func_1,thiz);
if(ret!=0)
{
perror("pthread_1_create:");
}
ret=pthread_create(&pt_2,NULL,(void*)pthread_func_2,thiz);
if(ret!=0)
{
perror("pthread_2_create:");
}
pthread_join(pt_1,NULL);
pthread_join(pt_2,NULL);
info_destroy(thiz);
return0;
}
staticvoidinfo_init(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
thiz->end_time=time(NULL)+10;
sem_init(&thiz->s1,0,1);
sem_init(&thiz->s2,0,0);
return;
}
staticvoidinfo_destroy(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
sem_destroy(&thiz->s1);
sem_destroy(&thiz->s2);
free(thiz);
thiz=NULL;
return;
}
staticvoid*pthread_func_1(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s2);
printf("pthread1:pthread1getthelock./n");
sem_post(&thiz->s1);
printf("pthread1:pthread1unlock/n");
sleep(1);
}
return;
}
staticvoid*pthread_func_2(PrivInfo*thiz)
{
return_if_fail(thiz!=NULL);
while(time(NULL)<thiz->end_time)
{
sem_wait(&thiz->s1);
printf("pthread2:pthread2gettheunlock./n");
sem_post(&thiz->s2);
printf("pthread2:pthread2unlock./n");
sleep(1);
}
return;
}

H. C語言中sync（）；什麼意思

sync是unistd.h頭文件內的函數，是unix,linux系統中的c函數，作用是將緩存中的信息寫入磁碟，以免困肢程序異常結束導致文件被損壞。在伏稿linux系統中關機缺尺孝前往往要sync幾次，這與sync()函數的作用類似。