Java 如何每10秒记录一次我的程序
嗨，我有一个程序，从服务器打印无限随机文本 在一段时间内循环，不会停止 ，如何在文本文件中每隔10秒记录一次数据Java 如何每10秒记录一次我的程序,java,file,logging,timer,Java,File,Logging,Timer,嗨，我有一个程序，从服务器打印无限随机文本 在一段时间内循环，不会停止 ，如何在文本文件中每隔10秒记录一次数据 public class MyServer { public static String str=""; private volatile boolean running=true; public synchronized void socketreceive(){ try{ ServerSocket ss=new ServerSocket(6666);
public class MyServer {
public static String str="";
private volatile boolean running=true;
public synchronized void socketreceive(){
try{
ServerSocket ss=new ServerSocket(6666);
Socket s=ss.accept();//establishes connection
DataInputStream dis=new DataInputStream(s.getInputStream());
str=(String)dis.readUTF();
//this continuously goes on and I need to make a log from it
System.out.println("message= "+str);
ss.close();
}catch(Exception e){}
}
public void receiver(){
final Thread receive=new Thread(new Runnable() {
@Override
public void run() {
while (running){
socketreceive();
}
}
});
您可以添加一个
if语句=public void run() {
Date dt = new Date();
DateFormat df = new SimpleDateFormat("ss");
while (running){
Date tmp = new Date();
if (Integer.parseInt(df.format(tmp)) - Integer.parseInt(df.format(dt)) >= 10)
// start your writer thread
dt = tmp
socketreceive();
}
我有一个例子，一个方便的计时器为这种情况。唯一的缺点是它是一个“摆动”计时器，在您的情况下，它可能是一个很重的计时器。不管它如何工作。我添加了一些用于读写的框架函数，这可能会为您提供一些想法
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Timer;
public class TimedLogger {
List<String> strings;
public mySocketReader() {
....
String line = str=(String)dis.readUTF();
storeLine(line);
..
}
synchronized void storeLine(String line) {
strings.add(line);
}
synchronized void writeLines() {
for(String s: strings)
writeInFile(s);
strings.clear();
}
Timer timer = new Timer(10000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
writeLines();
}
});
}
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入javax.swing.Timer；
公共类计时记录器{
列出字符串；
公共mySocketReader（）{
....
String line=str=（String）dis.readUTF（）；
店面线；
..
}
同步的void存储行（字符串行）{
字符串。添加（行）；
}
同步的void writeLines（）{
用于（字符串s:字符串）
书面文件；
strings.clear（）；
}
计时器计时器=新计时器（10000，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
writeLines（）；
}
});
}
您需要有2个（或更多列表）并使用synchronized函数来更改指向它们的指针。这是一个如何实现可能的解决方案的示例，在这个示例中，程序使用一个队列来存储来自多个套接字写入程序的值
Queue<String> logValues = new LinkedList<>();
public synchronized void log(String value) {
logValues.add(value);
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class ProgramLogger {
static final int serverPort = 9999;
public static void main(String args[]) {
ServerSocket serverSocket = null;
BufferLogger bufferLogger = new BufferLogger();
new Thread(bufferLogger).start();
Socket socket = null;
try {
serverSocket = new ServerSocket(serverPort);
new ClientSender().start(); //client 1
new ClientSender().start(); //client 2
new ClientSender().start(); //client 3
new ClientSender().start(); //client 4
} catch (IOException e) {
e.printStackTrace();
}
while (true) {
try {
socket = serverSocket.accept();
} catch (IOException e) {
e.printStackTrace();
}
new ServerReceptor(socket, bufferLogger).start();
}
}
}
class ClientSender extends Thread {
Socket socket;
PrintWriter out;
String serverAddress="localhost";
int serverPort=9999;
Random randomValue = new Random();
public void run() {
try {
System.out.println("Sarting Client Sender on Thread " + Thread.currentThread().toString());
socket = new Socket(serverAddress, serverPort);
out = out == null ? new PrintWriter(socket.getOutputStream(), true) : out;
while (!Thread.currentThread().isInterrupted()) {
out.println(Thread.currentThread().toString() + " - " + randomValue.nextInt(8000));
Thread.sleep(randomValue.nextInt(800));
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
class ServerReceptor extends Thread {
protected Socket socket;
private BufferLogger bufferLogger;
public ServerReceptor(Socket clientSocket, BufferLogger bufferLogger) {
this.socket = clientSocket;
this.bufferLogger = bufferLogger;
}
public void run() {
System.out.println("Sarting Server Receptor on Thread " + Thread.currentThread().toString());
InputStream inputStream = null;
BufferedReader bufferedReader = null;
DataOutputStream dataOutputStream = null;
try {
inputStream = socket.getInputStream();
bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
} catch (IOException e) {
return;
}
String line;
while (true) {
try {
line = bufferedReader.readLine();
if (line != null) {
bufferLogger.log(line);
}
} catch (IOException e) {
e.printStackTrace();
return;
}
}
}
}
class BufferLogger implements Runnable {
Queue<String> logValues = new LinkedList<>();
Date dateOfCreation = new Date();
String filename = String.format("myapplog%d.log", dateOfCreation.getTime());
public synchronized void log(String value) {
logValues.add(value);
}
public void writeToFile() {
Date date = new Date();
File myLog = new File(String.format(filename));
FileWriter myLogWritter = null;
try {
myLogWritter = new FileWriter(myLog, true);
int queueSize = logValues.size();
myLogWritter.write(String.format("Sending data to log!. Current Log Queue Size: %d. Time:%s%n", queueSize, date.toString()));
System.out.printf("Sending data to log!. Current Log Queue Size: %d. Time:%s. Filename:%s%n", queueSize, date.toString(), myLog.getName());
for (int i = 0; i < queueSize; i++) {
myLogWritter.write(String.format("%s Logging Value: %s%n", date.toString(), logValues.poll()));
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
myLogWritter.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
@Override
public void run() {
int timeToSave = 10000; //10 seconds
System.out.printf("Running Program Logger, log files every %d miliseconds. %s%n", timeToSave, new Date().toString());
while (!Thread.currentThread().isInterrupted()) {
try {
Thread.sleep(timeToSave);
this.writeToFile();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
import java.io.*；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.Date；
导入java.util.LinkedList；
导入java.util.Queue；
导入java.util.Random；
公共类程序记录器{
静态最终int服务器端口=9999；
公共静态void main（字符串参数[]）{
ServerSocket ServerSocket=null；
BufferLogger BufferLogger=新的BufferLogger（）；
新线程（bufferLogger）.start（）；
套接字=空；
试一试{
serverSocket=新的serverSocket（serverPort）；
新建ClientSender（）.start（）；//客户端1
新建ClientSender（）.start（）；//客户端2
新建ClientSender（）.start（）；//客户端3
新建ClientSender（）.start（）；//客户端4
}捕获（IOE异常）{
e、 printStackTrace（）；
}
while（true）{
试一试{
socket=serverSocket.accept（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
新的ServerReceptor（套接字、缓冲记录器）.start（）；
}
}
}
类ClientSender扩展线程{
插座；
打印输出；
字符串serverAddress=“localhost”；
int serverPort=9999；
Random randomValue=新的Random（）；
公开募捐{
试一试{
System.out.println（“线程上的Sarting客户端发送器”+Thread.currentThread（）.toString（））；
套接字=新套接字（服务器地址、服务器端口）；
out=out==null？新的PrintWriter（socket.getOutputStream（），true）：out；
而（！Thread.currentThread（）.isInterrupted（））{
out.println（Thread.currentThread（）.toString（）+“-”+randomValue.nextInt（8000））；
sleep（randomValue.nextInt（800））；
}
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
}
类ServerReceptor扩展线程{
保护插座；
专用缓冲记录器；
公共服务器接收器（套接字客户端套接字、缓冲记录器缓冲记录器）{
this.socket=clientSocket；
this.bufferLogger=缓冲记录器；
}
公开募捐{
System.out.println（“线程上的Sarting服务器接收器”+Thread.currentThread（）.toString（））；
InputStream InputStream=null；
BufferedReader BufferedReader=null；
DataOutputStream DataOutputStream=null；
试一试{
inputStream=socket.getInputStream（）；
bufferedReader=新的bufferedReader（新的InputStreamReader（inputStream））；
}捕获（IOE异常）{
返回；
}
弦线；
while（true）{
试一试{
line=bufferedReader.readLine（）；
如果（行！=null）{
log（行）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
返回；
}
}
}
}
类BufferLogger实现Runnable{
队列日志值=新建LinkedList（）；
创建日期=新日期（）；
String filename=String.format（“myapplog%d.log”，dateOfCreation.getTime（））；
公共同步作废日志（字符串值）{
logValues.add（value）；
}
public void writeToFile（）{
日期=新日期（）；
File myLog=新文件（String.format（filename））；
FileWriter MyLogWriter=null；
试一试{
MyLogWriter=新文件编写器（myLog，true）；
int queueSize=logValues.size（）；
MyLogWriter.write（String.format（“将数据发送到日志！。当前日志队列大小：%d。时间：%s%n”，队列大小，日期。toString（））；
System.out.printf（“将数据发送到日志！。当前日志队列大小：%d。时间：%s。文件名：%s%n”，队列大小，日期。toString（），myLog.getName（））；
对于（int i=0；iimport java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class ProgramLogger {
static final int serverPort = 9999;
public static void main(String args[]) {
ServerSocket serverSocket = null;
BufferLogger bufferLogger = new BufferLogger();
new Thread(bufferLogger).start();
Socket socket = null;
try {
serverSocket = new ServerSocket(serverPort);
new ClientSender().start(); //client 1
new ClientSender().start(); //client 2
new ClientSender().start(); //client 3
new ClientSender().start(); //client 4
} catch (IOException e) {
e.printStackTrace();
}
while (true) {
try {
socket = serverSocket.accept();
} catch (IOException e) {
e.printStackTrace();
}
new ServerReceptor(socket, bufferLogger).start();
}
}
}
class ClientSender extends Thread {
Socket socket;
PrintWriter out;
String serverAddress="localhost";
int serverPort=9999;
Random randomValue = new Random();
public void run() {
try {
System.out.println("Sarting Client Sender on Thread " + Thread.currentThread().toString());
socket = new Socket(serverAddress, serverPort);
out = out == null ? new PrintWriter(socket.getOutputStream(), true) : out;
while (!Thread.currentThread().isInterrupted()) {
out.println(Thread.currentThread().toString() + " - " + randomValue.nextInt(8000));
Thread.sleep(randomValue.nextInt(800));
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
class ServerReceptor extends Thread {
protected Socket socket;
private BufferLogger bufferLogger;
public ServerReceptor(Socket clientSocket, BufferLogger bufferLogger) {
this.socket = clientSocket;
this.bufferLogger = bufferLogger;
}
public void run() {
System.out.println("Sarting Server Receptor on Thread " + Thread.currentThread().toString());
InputStream inputStream = null;
BufferedReader bufferedReader = null;
DataOutputStream dataOutputStream = null;
try {
inputStream = socket.getInputStream();
bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
} catch (IOException e) {
return;
}
String line;
while (true) {
try {
line = bufferedReader.readLine();
if (line != null) {
bufferLogger.log(line);
}
} catch (IOException e) {
e.printStackTrace();
return;
}
}
}
}
class BufferLogger implements Runnable {
Queue<String> logValues = new LinkedList<>();
Date dateOfCreation = new Date();
String filename = String.format("myapplog%d.log", dateOfCreation.getTime());
public synchronized void log(String value) {
logValues.add(value);
}
public void writeToFile() {
Date date = new Date();
File myLog = new File(String.format(filename));
FileWriter myLogWritter = null;
try {
myLogWritter = new FileWriter(myLog, true);
int queueSize = logValues.size();
myLogWritter.write(String.format("Sending data to log!. Current Log Queue Size: %d. Time:%s%n", queueSize, date.toString()));
System.out.printf("Sending data to log!. Current Log Queue Size: %d. Time:%s. Filename:%s%n", queueSize, date.toString(), myLog.getName());
for (int i = 0; i < queueSize; i++) {
myLogWritter.write(String.format("%s Logging Value: %s%n", date.toString(), logValues.poll()));
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
myLogWritter.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
@Override
public void run() {
int timeToSave = 10000; //10 seconds
System.out.printf("Running Program Logger, log files every %d miliseconds. %s%n", timeToSave, new Date().toString());
while (!Thread.currentThread().isInterrupted()) {
try {
Thread.sleep(timeToSave);
this.writeToFile();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}