readfile共享读写（怎么实现串口共享）

本文目录

• 怎么实现串口共享
• LoadLibrary ReadFile MapViewOfFile 三者把文件加载进内存的区别
• 求多线程读取一个文件，然后写到另外一个文件中的Java实现
• vc++一个进程负责写入共享区,然后多个进程读取,会有什么异常吗
• Win32 同步串口编程 ReadFile接收不到数据，该怎么解决
• java中不同的线程可以同时操作一个文件吗

怎么实现串口共享

双击另一台电脑的网上邻居，打开后，一般即可看到你的共享文件了。注：有的电脑设置的防火墙会不让使用共享。你就要右键网上邻居－－属性－－更改Windows防火墙设置－－列外－－把文件和打印共享的前面的勾点击上。
两台机共享上网可选的方案很多，例如：（1）通过电缆线，利用串口或者并口实现双机互联。（2）利用两块网卡和双绞线实现双机互联。（3）利用USB口和特殊的USB联网线实现双机互联。（4）利用红外实现双机互联。
、WindowsAPI通信函数方法。与通信有关的WindowsAPI函数共有26个，但主要有关的有：CreateFile()用“comn”（n为串口号）作为文件名就可以打开串口。ReadFile()读串口。
简单~~看下面的把宽带猫的输出线，插到宽带路由器的WAN端口上，用网线把路由器LAN端口同电脑网卡相连。启动宽带猫和路由器的电源。
把两个串口交叉相连接\x0d\x0aTXD-RXD\x0d\x0aRXD-TXD\x0d\x0a是3引脚。\x0d\x0aGND在连下\x0d\x0a打开串口软件互发一下，测试是否通信成功。
选择通讯，单击-直接电缆连接-再利用Windows安装盘进行安装。安装好后，重新启动计算机。选定一台计算机作主机，在主机我的电脑中用右键某一驱动器选择共享选好共享级别。

LoadLibrary ReadFile MapViewOfFile 三者把文件加载进内存的区别

LoadLibrary 相当于“打开什么什么.DLL，返回它的句柄”，类似普通fopen, 返回 fp 的功能。

ReadFile 相当于 从文件里 读入指定字节数的数据，存入变量，类似普通的 fread的功能。

***隐藏网址***

这3者，并无大的关系。共性 是 都是 用于 文件 操作而已。

求多线程读取一个文件，然后写到另外一个文件中的Java实现

这个是我写的三个类，用于多线程操作读取文件内容和写入文件内容，不知道是不是你合你味口。
________________第一个类______读取内容__写入内容____________________
package pro;
import java.io.*;
public class ReadFileToWriteOtherFile {

private File oldFile;
private File newFile;
private BufferedReader br;
private BufferedWriter bw;
private String totalString="";
private Boolean flag=true; //用于标记文件名是否存在 true表示存在

public ReadFileToWriteOtherFile()
{
oldFile=null;
newFile=null;
br=null;
bw=null;
System.out.println("初始化成功");
}
public void readInfoFromFile(String fileName)
{

System.out.println("开始读取");
try
{

oldFile=new File(fileName);
if(oldFile.exists()) //如果文件存在
{
System.out.println("存在");
br=new BufferedReader(new FileReader(oldFile));
String info=br.readLine(); //读取一行
while(info!=null)
{
totalString+=info; //将读取到的一行添加到totalString中
info=br.readLine(); //再读取下一行
//System.out.println(totalString);
}
System.out.println("读取完成，准备写入…………");
}
else //如果文件不存在
{
System.out.println("文件不存在");
flag=false; //标记该文件不存在
}
// System.out.println("totalString="+totalString);
}
catch(FileNotFoundException e)
{
System.out.println(e);System.out.println("开始读取中1");
}
catch(IOException e)
{System.out.println(e);System.out.println("开始读取中2");}

}
public void writeInfoToFile(String fileName)
{
if(!flag) //如果标记前面的文件不存在，则return
{
flag=true; //改回原来的文件标记符
return;
}
try
{
newFile=new File(fileName);
if(newFile.exists()) //如果存在，不用创建新文件
{
System.out.println("文件存在，可以写入!");
}
else //如果不存在，则创建一个新文件
{
System.out.println("文件不存在，准备创建新文件");
newFile.createNewFile();
System.out.println("文件创建成功，可以写入");
}
bw=new BufferedWriter(new FileWriter(newFile,true));
// System.out.println("totalString="+totalString);
bw.write(totalString,0,totalString.length());
bw.flush(); //刷新缓冲区
System.out.println("写入完成");
totalString="\r\t"; //清空原来的字符串
}
catch(FileNotFoundException e)
{System.out.println(e);}
catch(IOException e)
{System.out.println(e);}

}
}
________________第二个类______一个自定义的线程类____________________
package pro;
import java.lang.Thread;
public class MyThread extends Thread
{
private int index; //用于数组的位置
private String fileNames; //定义一个字符串数组
ReadFileToWriteOtherFile bftwo=new ReadFileToWriteOtherFile(); //定义前面的自定义类
public MyThread(String fileNames,int index) //index表示数组位置标号
{
this.index=index;
this.fileNames=fileNames;
}
public void run()
{

bftwo.readInfoFromFile(fileNames);//传入数组中的字符串参数
bftwo.writeInfoToFile("b.txt"); //传入写入的目的地文件
//index++; //数组位置加1
System.out.println("==============");//分隔线

}
}
________________第三个类______主程序____________________
package pro;
//import org.springframework.context.ApplicationContext;
//import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.*;
public class BeanRunApp {

/**
* Method main
*
*
* @param args
*
*/
public static void main(String args)
{
/* ApplicationContext apc=new ClassPathXmlApplicationContext("beans.xml");
ClassRoom croom=(ClassRoom)apc.getBean("classRoom");
croom.out();
System.out.println("over");
*/
long startTime=System.currentTimeMillis();
String a={"a.txt","c.txt","d.txt","e.txt"}; //用一个符品数组保存文件名

for(int i=0;i《a.length;i++) //用数组的长度来作为循环条件
{ //把这个数组和i的值作为构造函数传入线程类
MyThread myth=new MyThread(a,i);
System.out.println("--------------------------------");
myth.start(); //执行
System.out.println("当前的线程是:"+myth.getName());
}
long endTime=System.currentTimeMillis();
System.out.println("耗时:"+(endTime-startTime)+"毫秒");
}
}

vc++一个进程负责写入共享区,然后多个进程读取,会有什么异常吗

WinSock(Windows Sockets)是处理网络通信的Windows API。许多函数与在BSD中使用的Berkely套接字函数是相同的。套接字，简单的说就是通信双方的一种约定，用套接字中的相关函数来完成通信过程。

应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP/IP协议交互提供了称为套接字(Socket)的接口。

Socket可以看成在两个程序进行通讯连接中的一个端点（endpoint），一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中。一般一个server服务器对应很多客户端client连接，服务器必须维护一张客户连接列表，每增加一个客户端连接服务器端都要新建一个套接字负责与新增客户端进行对话通信。

传输套接字主要有两类：流式套接字（SOCK_STREAM）和数据报套接字（SOCK_DGRAM）。流类型的套接字是为需要可靠连接的应用程序设计的。这些程序通常使用连续的数据流。用于这种类型套接字的协议是TCP，适合FTP这类实现。流套接字是最常用的，一些众所周知的协议如HTTP、TCP、SMTP、POP3等都是基于面向流的协议。

数据报套接字使用UDP做为下层协议，是无连接的，有一个最大缓冲区大小（数据包大小的最大值）。它是为那些需要发送小数据包，并且对可靠性要求不高的应用程序设计的。与流式套接字不同，数据报套接字并不保证数据会到达终端，也不保证它是以正确的顺序到来的。数据报套接字的传输效率相当高，它经常用于音频或视频应用程序。对这些程序来说，速度比可靠性更加重要。

一个连接由（server_ip, server_port）和（client_ip, client_port）唯一确定。你可以调用 getsockname() 函数获取与某个套接字关联的本地地址，调用 getpeername() 函数获取与某个套接字关联的目的地址。

套接字有阻塞（锁定）和非阻塞（非锁定）两种模式。非阻塞和阻塞描述的是 WinSock API 调用行为特性。

在一个阻塞套接字上调用任何 WinSock API 函数（accept()/recv()/send()），都会耗费或长或短的时间“等待”返回，这会阻塞调用线程。直到有点数据可读或可写时，这种调用才返回。

阻塞模式的优点是符合时序，容易入手。缺点也是显而易见的，假设这样一种情景，一个线程中要处理多个客户（套接字A、B），我们在套接字A、B上顺序调用recv企图依次接收数据。若客户A始终不发数据，则recv(A)函数将可能永远无法返回，在这期间我们错失了客户B发送来的数据。

大多数WinSock应用都遵循“生产者－消费者”模型，应用程序需要读取（或写入）指定数量的字节，然后再对读取的数据执行一些计算。在应用程序中，可以为每个套接字都创建一个负责读取网络数据的读线程（ReadThread），以及一个负责对数据执行计算的数据处理线程（ProcessThread）。尽管这会增大一些开销，但的确是一种可行的方案。缺点便是扩展性极差，而且无法应对大规模的通信情况。

将一个套接字置为非阻塞模式之后，WinSock API 调用会立即返回。大多数情况下，这些调用都会“失败”（SOCKET_ERROR），并返回一个WSAEWOULDBLOCK错误。它意味着请求的操作在调用期间没有时间完成。举个例子来说，假如在系统的输入缓冲区中，尚不存在“待决”的数据，那么recv()调用就会返回WSAEWOULDBLOCK错误。通常，我们需要重复调用同一个函数（轮询），直至获得一个成功返回代码。

假如需要编写更多的代码，以便在每个 Winsock调用中，对收到一个WSAEWOULDBLOCK错误的可能性加以应付，那么非阻塞套接字便显得有些难于操作。在这些情况下，可考虑使用“套接字I/O模型”，它管理I/O完成通知，帮助应用程序判断套接字何时可供读写。

套接字模式讨论的是套接字函数的调用特性，而I/O模型讨论的是调用背后的行为特性。

当CPU执行代码（当前活动线程）时遇上一个I/O请求（例如调用ReadFile()/WriteFile()或recv()/send()）时，系统产生一个中断，当前活动线程阻塞在此，让CPU去完成这个I/O请求，等到完成后，系统再次产生一个中断让原先的程序继续运行。也就说通过中断保持这两者间的同步，可以将中断理解为硬件化的信号量。

这就是所谓的同步I/O，一个线程中只可能同时处理一个I/O请求。因为一个I/O操作是非常耗时的，所以代码挂起后等待I/O完成的这段时间内，这个线程浪费了很多个指令周期。如果要同时反复读写大文件，则同步I/O的效率是很低的。

当然，可以考虑使用多线程来处理。例如在设计服务器时可以使用多线程来处理客户请求，每有一个客户连接请求，就创建一个新线程，专门处理它的通信请求。对于小型服务器来说，这不是问题。对于同时处理成千上万个请求的大型服务器而言，使用多线程是无效的，因为系统能够支持的线程数量毕竟是有限制的。另外一种解决方案就是使用共享负载的线程池，这涉及到异步I/O。

Win32 同步串口编程 ReadFile接收不到数据，该怎么解决

串口同步读写数据，ReadFile会一直阻塞，但是用串口调试助手可以接受到数据。
不过之后再启动程序就正常了，很郁闷，不知道问题出现在哪里，下面把代码贴出来：
以同步方式打开串口：
bool CSerialIO::openSerialPort(char* szSerial){HANDLE hSerial=CreateFileA(szSerial,
GENERIC_READ|GENERIC_WRITE,0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);if(INVALID_HANDLE_VALUE==hSerial)
return false;
this-》hComm=hSerial;
memcpy(cComm,szSerial,strlen(szSerial));
cComm=’\0’;
return true;}读串口：unsigned WINAPI RecieveData(void* pProcessData){ProcessData* pPD=(ProcessData*)pProcessData;while(1){if(pPD-》bClosePushThread==true)
ExitThread(0);
byte byteTempBuffer={0};
int iRead=0;
if(pPD-》pSerialIO-》readSerialPort(byteTempBuffer,511,iRead)){if(iRead《=0){Sleep(1000);continue;}else{pPD-》critSecData.lock();
pPD-》bVectorRawData.insert(pPD-》bVectorRawData.end(),byteTempBuffer,byteTempBuffer+iRead);
pPD-》critSecData.unLock();continue;}}Sleep(1000);}return 0;}这是一个线程入口函数，pPD-》pSerialIO-》readSerialPort(byteTempBuffer,511,iRead)这句代码实际上就是调用ReadFile来读串口数据，在这里设个断点，每次进入这个线程都会阻塞在这个地方，但是如果我用下串口调试助手后，就不会出现这个问题，也就是说 我要读写的串口必须要先被其他的进程读写过，然后才能正常运行。
ps：不要建议我异步读写串口，因为我现在问题还没解决。不知道是不是还需要对串口的参数进行设置。
再说下重点，我的程序可以正常运行的前提是：程序运行之前，用过串口调试助手之类的，也就是说必须要利用别的程序对串口的参数进行设置我的程序才能正常运行。

java中不同的线程可以同时操作一个文件吗

   Java中不同的线程是可以同时操作一个文件的，只不过有时候因为进程执行的快慢，会出现数据读取不同步的问题，例子如下：

Public class Readfile implements Runnable{
 
 public void run(){
  FileInputStream inputStream = new FileInputStream(file);//读数据
  byte;
  int size;
  while ((size = inputStream.read(buffer)) 》 0) {
   outputStream.write(buffer, 0, size);//写数据
  }
  inputStream.close();//
  outputStream.close();
 }
 
 public satatic void main(String args ) throws InterruptedException{
  Readfile rf = new Readfile(); 
 
  Thread t1 = new Thread(rf);//开启一个线程
  Thread t2 = new Thread(rf);//开启第二个线程
 
  t1.start();
  t2.start();
 }
}