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()函数的作用类似。