精华内容
参与话题
问答
  • C语言文件操作之----文件的读写

    万次阅读 2007-10-21 20:05:00
    针对文本文件和二进制文件的不同性质,对文本文件来说,可按字符读写或按字符串读写;对二进制文件来说,可进行成块的读写或格式化的读写。1. 读写字符 C提供fgetc和fputc函数对文本文件进行字符的读写,其函数的...
    当文件按指定的工作方式打开以后,就可以执行对文件的读和写。下面按文件的性质分类进行操作。针对文本文件和二进制文件的不同性质,对文本文件来说,可按字符读写或按字符串读写;对二进制文件来说,可进行成块的读写或格式化的读写。
    1. 读写字符
        C提供fgetc和fputc函数对文本文件进行字符的读写,其函数的原型存于stdio.h头文件中,格式为:
        int fgetc(FILE *stream)
        fgetc( )函数从输入流的当前位置返回一个字符,并将文件指针指示器移到下一个字符处,如果已到文件尾,函数返回EOF,此时表示本次操作结束,若读写文件完成,则应关闭文件。
    int fputc(int ch,FILE *stream)
    fputc()函数完成将字符c h的值写入所指定的流文件的当前位置处,并将文件指针后移一位。fputc()函数的返回值是所写入字符的值,出错时返回EOF。

    [例8-2] 将存放于磁盘的指定文本文件按读写字符方式逐个地从文件读出,然后再将其显示到屏幕上。采用带参数的main( ),指定的磁盘文件名由命令行方式通过键盘给定。
    #i nclude<stdio.h>
    main(argc,argv)
    int argc;
    char *argv[];
    {
        char ch;
        FILE *fp;
        int i;
        if((fp=fopen(argv[1],"r"))==NULL) /* 打开一个由argv[1]所指的文件*/
        {
            printf("not open");
            exit(0);
        }
        while ((ch=fgetc(fp))!=EOF) /* 从文件读一字符,显示到屏幕*/
            putchar(ch);
        fclose(fp);
    }
        程序是一带参数的main( )函数,要求以命令行方式运行,其参数argc是用于记录输入参数的个数, argv是指针数组,用于存放输入参数的字符串,串的个数由argc描述。假设我们指定读取的文件名为L8-2.c,并且列表文件内容就是源程序。经过编 译和连接生成可执行的文件L8-2.exe。运行程序l8-2.exe,输入的命令行方式为:
    c:/tc>l8-2 L8-2.c
        上述程序以命令行方式运行,其输入参数字符串有两个,即argv[0]="c:/tc>l8-2"、argv[1]=" L8-2.c ",argc = 2。故打开的文件是L8-2.c 。程序中对fgetc( )函数的返回值不断进行测试,若读到文件尾部或读文件出错,都将返回C的整型常量EOF,其值为非零有效整数。程序的运行输出为源程序本身:
    c:/tc>l8-2 L8-2.c
    #i nclude <stdio.h>
    main( argc,argv)
    int argc;
    char *argv[];
    {
        char ch;
        FILE *fp;
        int i;
        if((fp=fopen(argv[1],"r"))==NULL) /* 打开一个由argv[1] 所指的文件*/
        {
            printf("not open");
            exit(0);
        }
        while ((ch=fgetc(fp))!=EOF) /* 从文件读一字符,显示到屏幕*/
            putchar(ch);
        fclose(fp);
    }

    [例8-3] 从键盘输入字符,存到磁盘文件test.txt中:
    #i nclude <stdio.h>
    main( )
    {
        FILE fp; / *定义文件变量指针* /
        char ch;
        if((fp=fopen("test.txt","w"))==NULL)  /*以只写方式打开文件*/
        {
            printf("cannot open file!/n");
            exit(0);
        }
        while ((ch=fgetchar())!='/n') /*只要输入字符非回车符* /
            fputc(ch,fp) /*写入文件一个字符*/
        fclose(fp);
    }
        程序通过从键盘输入一以回车结束的字符串,写入指定的流文件test.txt,文件以文本只写方式打开,所以流文件具有可读性,能支持各种字符处理工具访问。简单地说,我们可以通过DOS提供的type命令来列表显示文件内容。
    运行程序:
    I love china!
    在DOS操作系统环境下,利用type 命令显示test.txt文件如下:
    c:/tc> type test.txt
    I love china!

    2. 读写字符串
        C提供读写字符串的函数原型在stdio.h头文件中,其函数形式为:
        Char *fgets(char *str,int num,FILE *stream)
        fgets() 函数从流文件stream中读取至多num-1个字符,并把它们放入str指向的字符数组中。读取字符直到遇见回车符或E O F(文件结束符)为止,或读入了所限定的字符数。
        int fputs(char *str,FILE *stream)
        fputs( )函数将str指向的字符串写入流文件。操作成功时,函数返回0值,失败返回非零值。

    [例8-4] 向磁盘写入字符串,并写入文本文件test.txt:
    #i nclude<stdio.h>
    #i nclude<string.h>
    main( )
    {
        FILE *fp;
        char str[128];
        if ((fp=fopen("test.txt","w"))==NULL) /*打开只写的文本文件*/
        {
            printf("cannot open file!");
            exit(0);
        }
        while((strlen(gets(str)))!=0)
        { /*若串长度为零,则结束*/
            fputs(str,fp); /*写入串*/
            fputs("/n",fp); /*写入回车符*/
        }
        fclose(fp); /*关文件*/
    }
        运行该程序,从键盘输入长度不超过1 2 7个字符的字符串,写入文件。如串长为0,即空串,程序结束。
    输入:Hello!
    How do you do
    Good-bye!

    运行结束后,我们利用dos的type命令列表文件:
    c:/tc>type test.txt
    Hello!
    How do you do
    Good-bye!
    这里所输入的空串,实际为一单独的回车符,其原因是gets函数判断串的结束是以回车作标志的。

    [例8-5] 从一个文本文件test1.txt中读出字符串,再写入令一个文件test2.txt。
    #i nclude<stdio.h>
    #i nclude<string.h>
    main( )
    {
        FILE *fp1,*fp2;
        char str[128];
        if ((fp1=fopen("test1.txt","r"))==NULL)
        { / * 以只读方式打开文件1 */
            printf("cannot open file/n");
            exit(0);
        }
        if((fp2=fopen("test2.txt","w"))==NULL)
        { /*以只写方式打开文件2 */
            printf("cannot open file/n");
            exit(0);
        }
        while ((strlen(fgets(str,128,fp1)))>0)
        /*从文件中读回的字符串长度大于0 */
        {
            fputs(str,fp2 ); /* 从文件1读字符串并写入文件2 */
            printf("%s",str); /*在屏幕显示*/
        }
        fclose(fp1);
        fclose(fp2);
    }
        程序共操作两个文件,需定义两个文件变量指针,因此在操作文件以前,应将两个文件以需要的工作方式同时打开(不分先后),读写完成后,再关闭文件。设计过 程是按写入文件的同时显示在屏幕上,故程序运行结束后,应看到增加了与原文件相同的文本文件并显示文件内容在屏幕上。

    3. 格式化的读写
        前面的程序设计中,我们介绍过利用scanf( )和printf( )函数从键盘格式化输入及在显示器上进行格式化输出。对文件的格式化读写就是在上述函数的前面加一个字母f成为fscanf( )和fprintf( )。其函数调用方式:
        int fscanf(FILE *stream,char *format,arg_list)
        int fprintf(FILE *stream,char *format,arg_list)
        其中,stream为流文件指针,其余两个参数与scanf( )和printf( )用法完全相同。

    [例8-6] 将一些格式化的数据写入文本文件,再从该文件中以格式化方法读出显示到屏
    幕上,其格式化数据是两个学生记录,包括姓名、学号、两科成绩。
    #i nclude<stdio.h>
    main( )
    {
        FILE *fp;
        int i;
        struct stu{ /*定义结构体类型*/
            char name[15];
            char num[6];
            float score[2];
        }student; /*说明结构体变量*/
        if((fp=fopen("test1.txt","w"))==NULL)
        { /*以文本只写方式打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("input data:/n");
        for( i=0;i<2;i++)
        {
            scanf("%s %s %f %f",student.name,student.num,&student.score[0],
            &student.score[1]); /*从键盘输入*/
            fprintf(fp,"%s %s %7.2f %7.2f/n",student.name,student.num,
            student.score[0],student.score[1]); /* 写入文件*/
        }
        fclose(fp); /*关闭文件*/
        if((fp=fopen("test.txt","r"))==NULL)
        { /*以文本只读方式重新打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("output from file:/n");
        while (fscanf(fp,"%s %s %f %f/n",student.name,student.num,&student.score[0],student.score[1])!=EOF)
        / *从文件读入* /
            printf("%s %s %7.2f %7.2f/n",student.name,student.num,
        student.score[0],student.score[1]); /* 显示到屏幕*/
        fclose(fp); /*关闭文件*/
    }
        程序设计一个文件变量指针,两次以不同方式打开同一文件,写入和读出格式化数据,有一点很重要,那就是用什么格式写入文件,就一定用什么格式从文件读,否则,读出的数据与格式控制符不一致,就造成数据出错。上述程序运行如下:
    input data:
    xiaowan j001 87.5 98.4
    xiaoli j002 99.5 89.6
    output from file:
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60

    列表文件的内容显示为:
    c:/>type test.txt
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60
        此程序所访问的文件也可以定为二进制文件,若打开文件的方式为:
    if ((fp=fopen("test1.txt","wb"))==NULL)
    { / * 以二进制只写方式打开文件* /
        printf("cannot open file");
        exit(0);
    }
    其效果完全相同。

    4. 成块读写
       
    前面介绍的几种读写文件的方法,对其复杂的数据类型无法以整体形式向文件写入或从文件读出。C语言提供成块的读写方式来操作文件,使其数组或结构体等类型可以进行一次性读写。成块读写文件函数的调用形式为:
        int fread(void *buf,int size,int count,FILE *stream)
        int fwrite(void *buf,int size,int count,FILE *stream)
        fread()函数从stream 指向的流文件读取count (字段数)个字段,每个字段为size(字段长度)个字符长,并把它们放到b u f(缓冲区)指向的字符数组中。
        fread()函数返回实际已读取的字段数。若函数调用时要求读取的字段数超过文件存放的字段数,则出错或已到文件尾,实际在操作时应注意检测。
        fwrite( )函数从buf(缓冲区)指向的字符数组中,把count(字段数)个字段写到stream所指向的流中,每个字段为size个字符长,函数操作成功时返回所写字段数。
        关于成块的文件读写,在创建文件时只能以二进制文件格式创建。

    [例8-7] 向磁盘写入格式化数据,再从该文件读出显示到屏幕。
    #i nclude "stdio.h"
    #i nclude "stdlib.h"
    main( )
    {
        FILE *fp1;
        int i;
        struct stu{ / *定义结构体*/
            char name[15];
            char num[6];
            float score[2];
        }student;
        if((fp1=fopen("test.txt","wb"))==NULL)
        { /*以二进制只写方式打开文件* /
            printf("cannot open file");
            exit(0);
        }
        printf("input data:/n");
        for( i=0;i<2;i++) 
        {
            scanf("%s %s %f %f",student.name,student.num,&student.score[0],&student.score[1]); /* 输入一记录*/
            fwrite(&student,sizeof(student),1,fp1); /* 成块写入文件*/
        }
        fclose(fp1);
        if((fp1=fopen("test.txt","rb"))==NULL)
        { /*重新以二进制只写打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("output from file:/n");
        for (i=0;i<2;i++)
        {
        fread(&student,sizeof(student),1,fp1); /* 从文件成块读*/
        printf("%s %s %7.2f %7.2f/n",student.name,student.num,student.score[0],student.score[1]); /* 显示到屏幕*/
        }
        fclose(fp1);
    }
    运行程序:
    input data:
    xiaowan j001 87.5 98.4
    xiaoli j002 99.5 89.6
    output from file:
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60
        通常,对于输入数据的格式较为复杂的话,我们可采取将各种格式的数据当做字符串输入,然后将字符串转换为所需的格式。C提供函数:
        int atoi(char *ptr)
        float atof(char *ptr)
        long int atol(char *ptr)
        它们分别将字符串转换为整型、实型和长整型。使用时请将其包含的头文件math.h或stdlib.h写在程序的前面。
    展开全文
  • 1 前言 为了降低耦合并提供强大的功能,Java提供了非常丰富多样的Stream类,如InputStream, OutputStream, BufferedStream等。强大的功能同样也是一把双刃剑,给使用记忆带来了很多麻烦,不是每个人都是天天使用Java...

    1 前言

    为了降低耦合并提供强大的功能,Java提供了非常丰富多样的Stream类,如InputStream, OutputStream, BufferedStream等。强大的功能同样也是一把双刃剑,给使用记忆带来了很多麻烦,不是每个人都是天天使用Java的这些类,并把它们记得非常清楚。相信有很多和笔者一样的人,每次在使用的时候,都需要查看相应的代码。为了解决这个问题,笔者根据常用的功能,编写了一个简易的Java类,TextWriter,专门用于文本的读写。

    2 功能描述

    这个类的主要就是用于将文本写入至文件中。文本写的时候其实只需要三步,打开,写入,关闭即可。所以对应的此类提供了相应的功能:

    2.1 打开

    打开是在新建的时候完成的,本类提供了三个构造函数,分别是

    // 需要写入的文件名
    TextWriter(String filename)
    // 需要写入的文件名和是否为追加模式,如果不是追加模式,且指定文件已经存在,则会清除原来存在的文件。
    TextWriter(String filename, boolean append)
    // 与上一个相比,增加了字符体,包括 US-ASCII,ISO-8859-1,UTF-8,UTF-16BE,UTF-16LE 和 UTF-16 
    TextWriter(String filename, boolean append, String charset)
    

    2.2 写入

    提供了两个函数用于写入分别如下:

    // 将字符串s追加至文件中。
    write(String s)
    // 将字符串s追加至文件中, 同时追加换行。在Windows下追加 \r\n,在Linux系统下追加 \n
    writeLine(String s)
    

    这两个是最基本的写入方便,如果觉得不够,比如 write(int v) 可以自行扩展。

    2.3 关闭

    每次写完记得调用close()方法保存即可。

    3 应用示例

    public static void main(String[] args) throws Exception {
    	String filename = "D:\\data\\text.txt";
    	TextWriter tw = new TextWriter(filename, false);
    	for(int i = 0; i < 10; i ++) {
    		tw.writeLine("同学1 i = " + i);
    	}
    	tw.close();
    	
    	tw = new TextWriter(filename, true);
    	for(int i = 0; i < 10; i ++) {
    		tw.writeLine("同学2 i = " + i);
    	}
    	tw.close();
    	System.out.println("Done.");
    }
    

    4 源代码

    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    /**
     * @author 郝伟老师
     * @date 2020/02/19
     * @description 一个简单的Java方便写入类。
     */
    public class TextWriter {
    
    	String filename;
    	String cs;  
    	RandomAccessFile raf;
    	String seperator;
    
    
    	void setSeperetor(){
    		seperator = new File("C:").exists() ? "\r\n" : "\n";
    	}
    
    	/**
    	 * 向一个文本文件中添加内容,默认编码为UTF8.
    	 * @param filepath 文件路径。
    	 */
    	public TextWriter(String filepath) throws IOException {
    		initialize(filename, false, "utf-8");
    	}
    	
    	/**
    	 * 向一个文本文件中添加内容,默认编码为UTF8.
    	 * @param filepath 文件路径。
    	 * @param append 是否追加。
    	 * @throws IOException
    	 */
    	public TextWriter(String filename, Boolean append) throws IOException{
    		initialize(filename, append, "utf-8");
    	} 
    
    	/**
    	 * 向一个文本文件中添加内容,默认编码为UTF8.
    	 * @param filepath 文件路径。
    	 * @param append 是否追加。
    	 * @param cs 编码格式,可以使用StandardCharsets表示。
    	 * @throws IOException
    	 */
    	public TextWriter(String filename, Boolean append, String charset) throws IOException{
    		initialize(filename, append, charset);
    	} 
    
    	private void initialize(String filename, Boolean append, String charset) throws IOException{
    		this.filename = filename;
    		this.cs = charset; 
    		setSeperetor(); 		
    		if(append) {
    			raf = new RandomAccessFile(this.filename, "rw");
    			raf.seek(raf.length());
    		}else{
    			File file = new File(filename);
    			if(file.exists()) {
    				file.delete();
    			}
    			raf = new RandomAccessFile(this.filename, "rw");
    		}
    	}
    	
    	/**
    	 * 写入指定的字符。
    	 * @param c 待写入字符。
    	 * @throws IOException
    	 */
    	public void write(char c) throws IOException{
    		write(c + "");
    	}
    	
    	/**
    	 * 写入指定的字符串。
    	 * @param s 待写入字符串。
    	 * @throws IOException
    	 */
    	public void write(String s) throws IOException{
    		raf.write(s == null ? new byte[0] : s.getBytes(cs));
    	}
    	
    	/**
    	 * 写入指定的字符串,并自动追加换行符。
    	 * @param s 待写入字符串。
    	 * @throws IOException
    	 */
    	public void writeLine(String s) throws IOException {
    		write(s);
    		write(seperator);
    	}
    	
    	public void close() throws IOException {
    		if(raf != null)
    			raf.close();
    	}	
    }
    
    
    展开全文
  • 读写者问题

    千次阅读 2018-09-18 09:48:51
    一、PV操作 1、信号量 PV操作与信号量的处理有关,信号量是表示资源的实体,是一个与队列有关的整型变量,其值只能由P、V操作来改变。操作系统利用信号量对进程和资源进行控制和管理。 ...信号量(Saphore)由一...

    一、PV操作

    1、信号量
    PV操作与信号量的处理有关,信号量是表示资源的实体,是一个与队列有关的整型变量,其值只能由P、V操作来改变。操作系统利用信号量对进程和资源进行控制和管理。

    2、PV操作实现
    信号量(Saphore)由一个值和一个指针组成,指针指向等待该信号量的进程。信号量的值表示相应资源的使用情况。信号量S>=0时,S表示可用资源的数量。执行一次P操作意味着请求分配一个资源,因此S的值减1;当S<0时,表示已经没有可用资源,S的绝对值表示当前等待该资源的进程数。请求者必须等待其他进程释放该类资源,才能继续运行。而执行一个V操作意味着释放一个资源,因此S的值加1;若S<0,表示有某些进程正在等待该资源,因此要唤醒一个等待状态的进程,使之运行下去。

    procedure P(var s:samephore);
    {
        s.value=s.value-1;
        if (s.value<0) 
        asleep(s.queue);
    }
    procedure V(var s:samephore);
    {
        s.value=s.value+1;
        if (s.value<=0) 
        wakeup(s.queue);
    }
    

    其中用到两个标准过程:

    asleep(s.queue):执行此操作的进程的PCB进入s.queue尾部,进程变成等待状态

    wakeup(s.queue):将s.queue头进程唤醒插入就绪队列

    s的初值为1时,可以用来实现进程的互斥,执行流程必须是P操作,V操作,P操作,V操作…

    二、读写者问题
    问题描述:
    有读者和写者两组并发进程,共享一个文件,当两个或以上的读进程同时访问共享数据时不会产生副作用,但若某个写进程和其他进程(读进程或写进程)同时访问共享数据时则可能导致数据不一致的错误。因此要求:①允许多个读者可以同时对文件执行读操作;②只允许一个写者往文件中写信息;③任一写者在完成写操作之前不允许其他读者或写者工作;④写者执行写操作前,应让已有的读者和写者全部退出。
    1、读者优先

    1. 关系分析。由题目分析读者和写者是互斥的,写者和写者也是互斥的,而读者和读者不存在互斥问题。

    2. 整理思路。两个进程,即读者和写者。写者是比较简单的,它和任何进程互斥,用互斥信号量的P操作、V操作即可解决。读者的问题比较复杂,它必须实现与写者互斥的同时还要实现与其他读者的同步,因此,仅仅简单的一对P操作、V操作是无法解决的。那么,在这里用到了一个计数器,用它来判断当前是否有读者读文件。当有读者的时候写者是无法写文件的,此时读者会一直占用文件,当没有读者的时候写者才可以写文件。同时这里不同读者对计数器的访问也应该是互斥的。

    3. 信号量设置。首先设置信号量count为计数器,用来记录当前读者数量,初值为0; 设置mutex为互斥信号量,用于保护更新count变量时的互斥;设置互斥信号量rw用于保证读者和写者的互斥访问。

    int count=0;  //用于记录当前的读者数量
    semaphore mutex=1;  //用于保护更新count变量时的互斥
    semaphore rw=1;  //用于保证读者和写者互斥地访问文件
    writer () {  //写者进程
        while (1){
            P(rw); // 互斥访问共享文件
            Writing;  //写入
            V(rw) ;  //释放共享文件
        }
    }
     
    reader () {  // 读者进程
        while(1){
            P (mutex) ;  //互斥访问count变量
            if (count==0)  //当第一个读进程读共享文件时
                P(rw);  //阻止写进程写
            count++;  //读者计数器加1
            V (mutex) ;  //释放互斥变量count
            reading;  //读取
            P (mutex) ;  //互斥访问count变量
            count--; //读者计数器减1
            if (count==0)  //当最后一个读进程读完共享文件
                V(rw) ;  //允许写进程写
            V (mutex) ;  //释放互斥变量 count
        }
    }
    

    2、写者优先
    在上面的算法中,读进程是优先的,也就是说,当存在读进程时,写操作将被延迟,并且只要有一个读进程活跃,随后而来的读进程都将被允许访问文件。这样的方式下,会导致写进程可能长时间等待,且存在写进程“饿死”的情况。

    如果希望写进程优先,即当有读进程正在读共享文件时,有写进程请求访问,这时应禁止后续读进程的请求,等待到已在共享文件的读进程执行完毕则立即让写进程执行,只有在无写进程执行的情况下才允许读进程再次运行。为此,增加一个信号量并且在上面的程序中 writer()和reader()函数中各增加一对PV操作,就可以得到写进程优先的解决程序。

    int count = 0;  //用于记录当前的读者数量
    semaphore mutex = 1;  //用于保护更新count变量时的互斥
    semaphore rw=1;  //用于保证读者和写者互斥地访问文件
    semaphore w=1;  //用于实现“写优先”
     
    writer(){
        while(1){
            P(w);  //在无写进程请求时进入
            P(rw);  //互斥访问共享文件
            writing;  //写入
            V(rw);  // 释放共享文件
            V(w) ;  //恢复对共享支件的访问
        }
    }
     
    reader () {  //读者进程
        while (1){
            P (w) ;  // 在无写进程请求时进入
            P (mutex);  // 互斥访问count变量
     
            if (count==0)  //当第一个读进程读共享文件时
                P(rw);  //阻止写进程写
     
            count++;  //读者计数器加1
            V (mutex) ;  //释放互斥变量count
            V(w);  //恢复对共享文件的访问
            reading;  //读取
            P (mutex) ; //互斥访问count变量
            count--;  //读者计数器减1
     
            if (count==0)  //当最后一个读进程读完共享文件
                V(rw);  //允许写进程写
     
            V (mutex);  //释放互斥变量count
        }
    }
    
    

    3、公平竞争

    展开全文
  • 读写

    千次阅读 2018-07-24 18:03:48
    ReadWriteLock也是一个接口,...基本规则: 读读不互斥 读写互斥 写写互斥    问题: 既然读读不互斥,为何还要加读锁  答: 如果只是读,是不需要加锁的,加锁本身就有性能上的损耗  如果读可以不是最新...

    ReadWriteLock也是一个接口,提供了readLock和writeLock两种锁的操作机制,一个资源可以被多个线程同时读,或者被一个线程写,但是不能同时存在读和写线程。   

    基本规则:  读读不互斥 读写互斥 写写互斥

     

       问题: 既然读读不互斥,为何还要加读锁

       答:  如果只是读,是不需要加锁的,加锁本身就有性能上的损耗

                如果读可以不是最新数据,也不需要加锁

                如果读必须是最新数据,必须加读写锁

                读写锁相较于互斥锁的优点仅仅是允许读读的并发,除此之外并无其他。

      

      结论: 读写锁能够保证读取数据的 严格实时性,如果不需要这种 严格实时性,那么不需要加读写锁。

    简单的实现:

    package readandwrite;
    
    import java.util.Random;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class MyTest {
    	private static ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
    	private static  double data=0;
    	static class readClass implements Runnable{
    		@Override
    		public void run() {
    			rwl.readLock().lock();
    			System.out.println("读数据:"+data);
    			rwl.readLock().unlock();
    		}
    	}
    	
    	static class writeClass implements Runnable{
    		private double i;
    		
    		public writeClass(double i) {
    			this.i = i;
    		}
    
    		@Override
    		public void run() {
    			rwl.writeLock().lock();
    			data=i;
    			System.out.println("写数据: "+data);
    			rwl.writeLock().unlock();
    		}
    		
    	}
    	 
    	public static void main(String[] args) throws InterruptedException {
    		ExecutorService pool=Executors.newCachedThreadPool();
    		for(int i=0;i<10;i++){
    			pool.submit(new readClass());
    			pool.submit(new writeClass((double)new Random().nextDouble()));
    			pool.submit(new writeClass((double)new Random().nextDouble()));
    			Thread.sleep(1000);
    		}
    		 
    		pool.shutdown();
    	}
    	
    
    }
    

     

    展开全文
  • 【Matlab学习手记】文件读写完整版

    万次阅读 多人点赞 2018-08-11 09:54:04
    介绍Matlab读写文本文件的方法,包括load、dlmread、csvread、importdata、textscan、dlmwrite、csvwrite、save等函数的用法。 读文件 1. 纯数字 load test.txt % 导入文本数据,并保存在 test 变量; x= ...
  • Java中各种读写文件的方法

    千次阅读 2018-12-14 15:37:21
    转载自:... 1、使用Scanner类解析文件。 (1)准备文件test.txt内容,内含字符、数字等文本信息; (2)使用Scanner类读取里面的字符信息和数字信息分别输出。 ...public c...
  • 【Python】读写

    2019-06-20 16:11:07
    # 打开和关闭文件 f = open("data.txt","r") f.close() # 为了方便,避免忘记close这个文件对象,用以下方式替代 with open('data.txt',"r") as f: str = f.read() # 读文件 f = open("data.txt",'r') ...
  • 硬盘的读写原理详解

    万次阅读 多人点赞 2012-03-29 17:30:30
    硬盘的种类主要是SCSI 、IDE 、以及现在流行的SATA等;任何一种硬盘的生产都要一定的标准;随着相应的标准的升级,硬盘生产技术也在升级;比如 SCSI标准已经经历了SCSI-1 、SCSI-2、SCSI-3;其中目前咱们经常在...
  • C++读写文本数据

    万次阅读 多人点赞 2017-10-24 14:58:23
    1、C++读写二进制文件 /***************************************************************** * \author DreamerZhang * \date 2019.08.27 * \brief 读取二进制文件,数据类型为short * \param fileName-...
  • 新视野大学英语(第三版)读写教程4答案

    万次阅读 多人点赞 2018-04-19 11:49:21
    Unit 1TextATextA . Language focus1. crumbled2. discern3. surpass4. shrewd5. conversion6. distort7. radiant8. Ingenious9. propositionTextA : Language focus Word building Practice 1delicacybankruptcyac....
  • 新视野大学英语(第三版) 读写教程4 课后答案

    万次阅读 多人点赞 2019-05-21 12:59:13
    Unit 1 TextA TextA . Language focus crumbled discern surpass shrewd conversion distort radiant Ingenious proposition TextA : Language focus Word building Practice 1 delicac...
  • Python开发 之 Python3读写Excel文件(较全)

    万次阅读 多人点赞 2018-10-17 10:17:52
    Python读写Excel文件用xlrd包读取Excel文件 用xlrd包读取Excel文件 用法比较简单。 import xlrd import xlwt import openpyxl from datetime import date,datetime arrayNum = 6 #array = {'L1':'','L2':'...
  • 用python读写和处理csv文件

    万次阅读 多人点赞 2018-07-18 22:13:43
    用python读写和处理csv文件 读取 这里我们使用pandas包来读取csv文件,pandans处理csv文件十分方便我认为是目前最方便的读取方式 首先安装pandans pip install pandans 安装好了之后我们读取一个csv文件 ...
  • C语言操作EXCEL文件(读写)

    万次阅读 多人点赞 2017-02-26 18:18:37
    C语言操作EXCEL文件(读写) 本文主要介绍通过纯C语言进行EXCEL的读写操作: C语言读操作 C语言写操作 在之前需要使用C语言读取Excel文件内容的功能,查阅了很多资料,大部分是通过ODBC或者过OLE/...
  • C++ 读写txt文件类

    千次阅读 2018-08-16 21:35:51
    C++ 读写txt文件类 C++ 读写txt文件类 代码如下: 运行结果: 封装一个C++简单的类,用于读写txt文件。 代码如下: comFile.h #pragma once #include &lt;iostream&gt; #include &...
  • C语言文件读写函数总结

    千次阅读 多人点赞 2018-04-30 23:51:59
    一、字符读写 1、字符写入文件函数 fputc 2、从文件中读取字符 fgetc 二、字符串的读写 1、字符串写入文件函数 fputs 2、从文件中读取字符 fgets 三、块数据读写 1、向文件中写入块数据fwrite 2、从文件中...
  • C++读写txt文件(基本操作1)

    万次阅读 多人点赞 2017-11-30 17:49:02
    本博客主要写了用C++读写txt本文的基本操作,最简单的写入和读出两个基本操作。 本程序的功能是向Test.txt文件文件写入字符串"This is a Test12!"和读取字符串"This is a Test12!",并且将读取到的字符串存到temp...
  • mysql数据库的主从同步,实现读写分离

    万次阅读 多人点赞 2018-08-14 20:55:57
    目录 前言 1 分别在两台centos 7系统上安装mysql 5.7 2 master主服务器的配置 2.1 配置文件my.cnf的修改 2.2 创建从服务器的用户和权限 2.3 重启mysql服务 2.4 查看主服务器状态 ...3.4 启动slav...
  • Python使用csv模块读写csv文件

    万次阅读 2019-05-26 17:18:09
    Python使用csv模块读写csv文件 csv是逗号分隔值(Comma-Separated Values)的简称。 有时也称为字符分隔值,因为分隔字符也可以不是逗号,其文件以纯文本形式存储表格数据。纯文本意味着该文件是一个字符序列,...
  • 纯c读写ini配置文件

    千次下载 热门讨论 2015-10-14 11:40:56
    纯c读写ini配置文件 用c/c++读写ini配置文件有不少第三方的开源库,如iniparser、libini、rwini、UltraLightINIParser等,但都不理想,往往代码较大、功能较弱、 接口使用不方便。尤其在大小写处理、前后空格、各种...

空空如也

1 2 3 4 5 ... 20
收藏数 1,154,365
精华内容 461,746
关键字:

读写