java多线程tcp物联网,物联网Java服务端TCP通讯

时间: 2023-07-09 17:30:48 浏览: 31
好的,您想了解关于Java多线程TCP通讯在物联网服务端的应用吗? 首先,TCP通讯是指通过TCP协议进行的网络通讯。在物联网服务端,我们可以使用Java中的Socket类和ServerSocket类来实现TCP通讯。具体实现中,我们可以使用多线程来提高服务端的并发处理能力。 以下是一个简单的示例代码,实现了一个基于多线程的物联网Java服务端TCP通讯: ```java import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class IoTServer { public static void main(String[] args) throws IOException { int port = 8888; ServerSocket serverSocket = new ServerSocket(port); System.out.println("服务器已启动,等待客户端连接..."); while (true) { Socket socket = serverSocket.accept(); System.out.println("客户端已连接,IP地址为:" + socket.getInetAddress().getHostAddress()); new Thread(new IoTServerHandler(socket)).start(); } } static class IoTServerHandler implements Runnable { private Socket socket; public IoTServerHandler(Socket socket) { this.socket = socket; } @Override public void run() { try { // 获取输入流 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 获取输出流 PrintWriter out = new PrintWriter(socket.getOutputStream()); String line; while ((line = in.readLine()) != null) { System.out.println("客户端:" + line); out.println("服务端已收到消息:" + line); out.flush(); } } catch (IOException e) { e.printStackTrace(); } finally { try { socket.close(); } catch (IOException e) { e.printStackTrace(); } } } } } ``` 以上代码中,我们使用ServerSocket监听指定端口,并在接收到客户端连接后开启一个新线程处理该连接。在IoTServerHandler中,我们通过输入流读取客户端发送的消息,并通过输出流向客户端发送响应。 当然,这只是一个简单的示例,实际应用中我们需要根据具体需求进行更加细致的设计和实现。

相关推荐

多线程TCP连接是一种在Java中实现的技术。它允许多个客户端同时连接到服务器,并在不同的线程中处理每个客户端的请求。通过使用多线程,服务器可以同时处理多个客户端的请求,提高了系统的并发性能。 在Java中,可以使用Socket类和ServerSocket类来实现多线程TCP连接。ServerSocket类用于创建服务器端的套接字,而Socket类用于创建客户端的套接字。当客户端连接到服务器时,服务器通过接受客户端的套接字来建立连接。然后,服务器可以为每个客户端创建一个新的线程来处理其请求。 以下是实现多线程TCP连接的一般步骤: 1. 创建ServerSocket对象,并指定服务器端口号。 2. 使用accept()方法等待客户端连接,并接受客户端的套接字。 3. 创建一个新的线程,并将接受到的套接字传递给该线程。 4. 在新线程中,使用Socket对象来与客户端进行通信。可以使用InputStream和OutputStream来读取和写入数据。 5. 当客户端请求完成后,关闭套接字和线程。 通过使用多线程TCP连接,可以实现高效的网络通信,并提供更好的用户体验。同时,Java的多线程机制也使得实现多线程TCP连接变得相对简单和方便。1 #### 引用[.reference_title] - *1* [TCP.rar_java Tcp _tcp java_tcp 多线程_tcp多线程](https://download.csdn.net/download/weixin_42650811/86660539)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT0_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
好的,这是一个比较常见的问题。以下是一个简单的Java Socket客户端多线程TCP实现的示例代码: java import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; public class ClientThread extends Thread { private Socket socket; public ClientThread(Socket socket) { this.socket = socket; } public void run() { try { BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream())); PrintWriter output = new PrintWriter(socket.getOutputStream(), true); String message = input.readLine(); System.out.println("Received message: " + message); // 处理客户端请求 String response = processRequest(message); output.println(response); socket.close(); } catch (Exception e) { e.printStackTrace(); } } private String processRequest(String message) { // 处理客户端请求的逻辑 return "Processed request: " + message; } } 在主程序中,我们可以创建多个客户端线程,每个线程处理一个客户端连接: java import java.net.ServerSocket; import java.net.Socket; public class Server { public static void main(String[] args) throws Exception { ServerSocket serverSocket = new ServerSocket(8080); while (true) { Socket socket = serverSocket.accept(); ClientThread clientThread = new ClientThread(socket); clientThread.start(); } } } 在这个示例代码中,我们创建了一个ServerSocket并监听8080端口。当有客户端连接时,我们创建一个ClientThread线程来处理这个连接。每个线程处理完一个连接后就会关闭这个连接。 上面的示例代码只是一个简单的例子,实际情况下,我们需要考虑更多的因素,例如线程池大小、请求队列长度、异常处理等等。但是这个示例代码可以帮助你理解如何使用Java Socket实现多线程TCP客户端。
以下是Qt多线程TCP服务端的实现示例: 1. 创建一个Qt控制台应用程序。 2. 在项目中添加一个新的类来实现TCP服务器。我们将称之为"TcpServer"。 3. 在TcpServer类的头文件中,添加以下内容: #ifndef TCPSERVER_H #define TCPSERVER_H #include <QObject> #include <QTcpServer> #include <QTcpSocket> #include <QThread> class TcpServer : public QObject { Q_OBJECT public: explicit TcpServer(QObject *parent = nullptr); public slots: void newConnection(); //处理新连接 void readData(); //读取数据 void socketDisconnected(); //处理断开连接 private: QTcpServer *m_server = nullptr; //TCP服务器 QList<QTcpSocket*> m_sockets; //已连接的TCP套接字 }; #endif // TCPSERVER_H 4. 在TcpServer类的源文件中,实现以下内容: #include "tcpserver.h" TcpServer::TcpServer(QObject *parent) : QObject(parent) { m_server = new QTcpServer(this); connect(m_server, &QTcpServer::newConnection, this, &TcpServer::newConnection); if (!m_server->listen(QHostAddress::Any, 1234)) { qWarning() << "Could not start server"; } else { qDebug() << "Listening on port 1234..."; } } void TcpServer::newConnection() { QTcpSocket *socket = m_server->nextPendingConnection(); connect(socket, &QTcpSocket::readyRead, this, &TcpServer::readData); connect(socket, &QTcpSocket::disconnected, this, &TcpServer::socketDisconnected); m_sockets.append(socket); } void TcpServer::readData() { QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender()); if (!socket) { return; } QByteArray data = socket->readAll(); qDebug() << "Received data:" << data; //将数据发送回客户端 socket->write(data); } void TcpServer::socketDisconnected() { QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender()); if (!socket) { return; } m_sockets.removeOne(socket); socket->deleteLater(); } 5. 在main.cpp文件中,实例化TcpServer类并将其移动到一个新的线程中: #include <QCoreApplication> #include <QThread> #include "tcpserver.h" int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); //创建TcpServer对象 TcpServer *server = new TcpServer(); //创建新线程并将服务器对象移动到该线程 QThread *thread = new QThread(); server->moveToThread(thread); thread->start(); return a.exec(); } 这样,我们就创建了一个基本的Qt多线程TCP服务端。当客户端连接到服务器时,服务器将打印出"Listening on port 1234..."。当客户端发送数据时,服务器将打印出接收到的数据并将其发送回客户端。当客户端断开连接时,服务器将从已连接的套接字列表中删除该套接字。
连接的步骤是什么? 首先,你需要创建一个ServerSocket对象并指定端口号。然后,在无限循环中,等待客户端连接请求。一旦有连接请求,就创建一个新的Socket对象来处理连接,并将Socket传递给一个新的线程来处理。在线程中,你可以使用Socket对象中的输入和输出流来进行通信。最后,关闭Socket和ServerSocket对象,释放资源。以下是Java代码示例: import java.net.*; import java.io.*; public class MultiThreadedServer implements Runnable { private Socket clientSocket; public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(8080); System.out.println("Server started."); while (true) { System.out.println("Waiting for a client ..."); Socket socket = serverSocket.accept(); System.out.println("Client accepted"); new Thread(new MultiThreadedServer(socket)).start(); } } catch (IOException e) { e.printStackTrace(); } finally { if (serverSocket != null) { serverSocket.close(); } } } public MultiThreadedServer(Socket socket) { this.clientSocket = socket; } public void run() { try { PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); String inputLine; while ((inputLine = in.readLine()) != null) { System.out.println("Received message: " + inputLine); out.println(inputLine); } in.close(); out.close(); clientSocket.close(); } catch (IOException e) { e.printStackTrace(); } } }
如果你想在Java Socket客户端多线程TCP实现中使用16进制数据,可以使用Java的DataInputStream和DataOutputStream类来实现。 以下是一个简单的Java Socket客户端多线程TCP实现的示例代码,它可以发送和接收16进制数据: java import java.io.DataInputStream; import java.io.DataOutputStream; import java.net.Socket; public class ClientThread extends Thread { private Socket socket; public ClientThread(Socket socket) { this.socket = socket; } public void run() { try { DataInputStream input = new DataInputStream(socket.getInputStream()); DataOutputStream output = new DataOutputStream(socket.getOutputStream()); // 发送16进制数据 byte[] sendData = new byte[]{0x12, 0x34, 0x56}; output.write(sendData); output.flush(); System.out.println("Sent data: " + bytesToHex(sendData)); // 接收16进制数据 byte[] receiveData = new byte[1024]; int receiveLen = input.read(receiveData); byte[] actualData = Arrays.copyOfRange(receiveData, 0, receiveLen); System.out.println("Received data: " + bytesToHex(actualData)); socket.close(); } catch (Exception e) { e.printStackTrace(); } } private static String bytesToHex(byte[] bytes) { StringBuilder sb = new StringBuilder(); for (byte b : bytes) { sb.append(String.format("%02X", b)); } return sb.toString(); } } 在主程序中,我们可以创建多个客户端线程,每个线程处理一个客户端连接: java import java.net.ServerSocket; import java.net.Socket; public class Server { public static void main(String[] args) throws Exception { ServerSocket serverSocket = new ServerSocket(8080); while (true) { Socket socket = serverSocket.accept(); ClientThread clientThread = new ClientThread(socket); clientThread.start(); } } } 在这个示例代码中,我们创建了一个ServerSocket并监听8080端口。当有客户端连接时,我们创建一个ClientThread线程来处理这个连接。每个线程处理完一个连接后就会关闭这个连接。 注意,在发送和接收16进制数据时,需要调用DataOutputStream.write(byte[] b)和DataInputStream.read(byte[] b)方法,而不是PrintWriter.println(String s)和BufferedReader.readLine()方法。
QT TCP多线程服务端可以实现同时处理多个客户端请求,提高服务端的并发处理能力。下面是实现步骤: 1. 创建QT TCP服务器端程序,包括界面设计和程序逻辑。 2. 使用QT的QThread类创建多线程,每个线程负责处理一个客户端请求。具体实现方法如下: - 在主线程中创建一个QTcpServer对象,并监听指定的端口; - 当有一个客户端请求连接时,主线程会调用QTcpServer的incomingConnection()函数,在该函数中创建一个新的线程,并将新连接的QTcpSocket对象移动到该线程中; - 在新线程中,使用QTcpSocket对象来和客户端进行通信,接收和发送数据; - 在新线程中,需要重写run()函数,实现线程的具体逻辑,包括接收和处理客户端请求。 3. 在QTcpSocket的readyRead()信号中,接收客户端发送的数据,并在新线程中处理数据。 4. 在QTcpSocket的disconnected()信号中,处理客户端断开连接的情况,释放相关资源。 5. 在程序结束时,释放QTcpServer对象和所有线程的资源。 下面是一个简单的QT TCP多线程服务端示例代码: cpp #include <QApplication> #include <QWidget> #include <QTcpServer> #include <QTcpSocket> #include <QThread> class ClientThread : public QThread { Q_OBJECT public: explicit ClientThread(QTcpSocket *socket, QObject *parent = nullptr) : QThread(parent), m_socket(socket) {} protected: void run() override { // 在新线程中处理客户端请求 QByteArray data = m_socket->readAll(); // 处理数据... m_socket->write("Server response"); // 断开连接 m_socket->disconnectFromHost(); m_socket->deleteLater(); } private: QTcpSocket *m_socket; }; class Server : public QWidget { Q_OBJECT public: explicit Server(QWidget *parent = nullptr) : QWidget(parent) { m_server = new QTcpServer(this); m_server->listen(QHostAddress::Any, 8888); connect(m_server, &QTcpServer::newConnection, this, &Server::onNewConnection); } private slots: void onNewConnection() { // 创建新线程处理客户端请求 QTcpSocket *socket = m_server->nextPendingConnection(); ClientThread *thread = new ClientThread(socket, this); thread->start(); } private: QTcpServer *m_server; }; int main(int argc, char *argv[]) { QApplication app(argc, argv); Server server; server.show(); return app.exec(); } #include "main.moc"
可以使用Java的多线程和UDP/TCP协议来实现扫描UDP/TCP端口。以下是一个简单的示例代码: java import java.io.IOException; import java.net.Socket; import java.net.SocketException; public class PortScanner { public static void main(String[] args) { int startPort = 1; int endPort = 65535; String ipAddress = "127.0.0.1"; // Scan UDP ports for(int port = startPort; port <= endPort; port++) { Runnable udpScanner = new UDPPortScanner(ipAddress, port); Thread udpThread = new Thread(udpScanner); udpThread.start(); } // Scan TCP ports for(int port = startPort; port <= endPort; port++) { Runnable tcpScanner = new TCPPortScanner(ipAddress, port); Thread tcpThread = new Thread(tcpScanner); tcpThread.start(); } } static class UDPPortScanner implements Runnable { private String ipAddress; private int port; public UDPPortScanner(String ipAddress, int port) { this.ipAddress = ipAddress; this.port = port; } @Override public void run() { try { DatagramSocket socket = new DatagramSocket(); socket.connect(ipAddress, port); socket.close(); System.out.println("UDP port " + port + " is open"); } catch (SocketException e) { // port is closed or an error occurred } } } static class TCPPortScanner implements Runnable { private String ipAddress; private int port; public TCPPortScanner(String ipAddress, int port) { this.ipAddress = ipAddress; this.port = port; } @Override public void run() { try { Socket socket = new Socket(ipAddress, port); socket.close(); System.out.println("TCP port " + port + " is open"); } catch (IOException e) { // port is closed or an error occurred } } } } 该代码会启动多个线程,每个线程扫描一个UDP/TCP端口。如果端口是开放的,它将输出一条消息。请注意,该示例代码只是一个简单的示例,实际应用中可能需要更多的优化和错误处理。
实现TCP多线程传输文件可以分为以下步骤: 1. 创建一个ServerSocket,监听客户端的连接请求。 2. 当有客户端连接时,创建一个新的线程来处理客户端的请求。 3. 在新的线程中,创建一个Socket与客户端进行通信。 4. 通过Socket获取输入输出流,进行文件的读写。 5. 将文件分成多个块,每个块单独发送,接收方将块合并成完整文件。 下面是一个示例代码,实现了TCP多线程传输文件: java import java.io.*; import java.net.*; public class Server { public static void main(String[] args) { try { // 创建ServerSocket,监听客户端的连接请求 ServerSocket serverSocket = new ServerSocket(8888); System.out.println("服务器启动,等待客户端连接..."); while (true) { // 当有客户端连接时,创建一个新的线程来处理客户端的请求 Socket clientSocket = serverSocket.accept(); System.out.println("客户端 " + clientSocket.getInetAddress().getHostAddress() + " 连接成功"); Thread thread = new Thread(new ClientHandler(clientSocket)); thread.start(); } } catch (IOException e) { e.printStackTrace(); } } // 处理客户端请求的线程 static class ClientHandler implements Runnable { private Socket clientSocket; public ClientHandler(Socket clientSocket) { this.clientSocket = clientSocket; } @Override public void run() { try { // 通过Socket获取输入输出流 DataInputStream dis = new DataInputStream(clientSocket.getInputStream()); DataOutputStream dos = new DataOutputStream(clientSocket.getOutputStream()); // 读取客户端传来的文件名和大小 String fileName = dis.readUTF(); long fileSize = dis.readLong(); System.out.println("客户端传来的文件名:" + fileName); System.out.println("客户端传来的文件大小:" + fileSize + " 字节"); // 创建文件输出流,将文件写入到服务器端指定目录 FileOutputStream fos = new FileOutputStream("/path/to/save/" + fileName); // 将文件分成多个块,每个块单独发送 byte[] buffer = new byte[1024]; int len; while ((len = dis.read(buffer)) != -1) { fos.write(buffer, 0, len); } // 关闭流 fos.close(); dis.close(); dos.close(); clientSocket.close(); System.out.println("文件接收成功"); } catch (IOException e) { e.printStackTrace(); } } } } 客户端代码如下: java import java.io.*; import java.net.*; public class Client { public static void main(String[] args) { try { // 创建Socket,连接服务器 Socket socket = new Socket("localhost", 8888); System.out.println("连接服务器成功"); // 通过Socket获取输入输出流 DataInputStream dis = new DataInputStream(socket.getInputStream()); DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); // 读取本地文件,将文件名和大小发送给服务器 File file = new File("/path/to/file"); String fileName = file.getName(); long fileSize = file.length(); dos.writeUTF(fileName); dos.writeLong(fileSize); System.out.println("文件名:" + fileName); System.out.println("文件大小:" + fileSize + " 字节"); // 创建文件输入流,将文件发送给服务器 FileInputStream fis = new FileInputStream(file); byte[] buffer = new byte[1024]; int len; while ((len = fis.read(buffer)) != -1) { dos.write(buffer, 0, len); } // 关闭流 fis.close(); dis.close(); dos.close(); socket.close(); System.out.println("文件发送成功"); } catch (IOException e) { e.printStackTrace(); } } } 在这个示例代码中,服务器和客户端都是单线程的,每次只能处理一个客户端请求。如果需要支持多个客户端同时连接,可以使用线程池来管理多个线程,每个线程负责处理一个客户端请求。
以下是一个简单的TCP双人聊天Java程序实现,并使用了线程: Server端代码: java import java.net.*; import java.io.*; public class Server { public static void main(String[] args) throws IOException { ServerSocket serverSocket = null; try { serverSocket = new ServerSocket(5000); } catch (IOException e) { System.err.println("Could not listen on port: 5000."); System.exit(1); } System.out.println("Server started. Listening on port 5000..."); Socket clientSocket = null; try { clientSocket = serverSocket.accept(); } catch (IOException e) { System.err.println("Accept failed."); System.exit(1); } System.out.println("Client connected: " + clientSocket.getInetAddress().getHostName()); PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); // Create a new thread for receiving messages from client Thread receiverThread = new Thread(new Runnable() { @Override public void run() { String inputLine; try { while ((inputLine = in.readLine()) != null) { System.out.println("Client: " + inputLine); } } catch (IOException e) { System.err.println("Receiver thread error."); System.exit(1); } } }); receiverThread.start(); // Main thread for sending messages to client BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); String userInput; try { while ((userInput = stdIn.readLine()) != null) { out.println(userInput); } } catch (IOException e) { System.err.println("Sender thread error."); System.exit(1); } out.close(); in.close(); clientSocket.close(); serverSocket.close(); } } Client端代码: java import java.net.*; import java.io.*; public class Client { public static void main(String[] args) throws IOException { Socket serverSocket = null; try { serverSocket = new Socket("localhost", 5000); } catch (UnknownHostException e) { System.err.println("Unknown host: localhost."); System.exit(1); } catch (IOException e) { System.err.println("Could not connect to localhost."); System.exit(1); } System.out.println("Connected to server: " + serverSocket.getInetAddress().getHostName()); PrintWriter out = new PrintWriter(serverSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(serverSocket.getInputStream())); // Create a new thread for receiving messages from server Thread receiverThread = new Thread(new Runnable() { @Override public void run() { String inputLine; try { while ((inputLine = in.readLine()) != null) { System.out.println("Server: " + inputLine); } } catch (IOException e) { System.err.println("Receiver thread error."); System.exit(1); } } }); receiverThread.start(); // Main thread for sending messages to server BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); String userInput; try { while ((userInput = stdIn.readLine()) != null) { out.println(userInput); } } catch (IOException e) { System.err.println("Sender thread error."); System.exit(1); } out.close(); in.close(); serverSocket.close(); } } 在这个实现中,服务器和客户端都使用了一个线程来接收来自对方的消息,并使用主线程来发送消息。这个实现可能存在一些问题,比如没有处理异常或者没有关闭socket等,但可以作为一个简单的例子来理解TCP双人聊天的实现方式。

最新推荐

Java多线程之volatile关键字及内存屏障实例解析

volatile是JVM提供的一种最轻量级的同步机制,因为Java内存模型为volatile定义特殊的访问规则,使其可以实现Java内存模型中的两大特性...这篇文章主要介绍了Java多线程之volatile关键字及内存屏障,需要的朋友可以参考下

Java编程实现多线程TCP服务器完整实例

主要介绍了Java编程实现多线程TCP服务器完整实例,具有一定借鉴价值,需要的朋友可以参考下

java多线程之火车售票系统模拟实例

下面小编就为大家带来一篇java多线程之火车售票系统模拟实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧

Java多线程之多线程异常捕捉

在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉,通过此篇文章给大家分享Java多线程之多线程异常捕捉,需要的朋友可以参考下

Java多线程模拟电影售票过程

主要为大家详细介绍了Java多线程模拟电影售票过程,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

MATLAB遗传算法工具箱在函数优化中的应用.pptx

MATLAB遗传算法工具箱在函数优化中的应用.pptx

网格QCD优化和分布式内存的多主题表示

网格QCD优化和分布式内存的多主题表示引用此版本:迈克尔·克鲁斯。网格QCD优化和分布式内存的多主题表示。计算机与社会[cs.CY]南巴黎大学-巴黎第十一大学,2014年。英语。NNT:2014PA112198。电话:01078440HAL ID:电话:01078440https://hal.inria.fr/tel-01078440提交日期:2014年HAL是一个多学科的开放存取档案馆,用于存放和传播科学研究论文,无论它们是否被公开。论文可以来自法国或国外的教学和研究机构,也可以来自公共或私人研究中心。L’archive ouverte pluridisciplinaireU大学巴黎-南部ECOLE DOCTORALE d'INFORMATIQUEDEPARIS- SUDINRIASAACALLE-DE-FRANCE/L ABORATOIrEDERECHERCH EEE NINFORMATIqueD.坐骨神经痛:我的格式是T是博士学位2014年9月26日由迈克尔·克鲁斯网格QCD优化和分布式内存的论文主任:克里斯汀·艾森贝斯研究主任(INRIA,LRI,巴黎第十一大学)评审团组成:报告员:M. 菲利普�

gru预测模型python

以下是一个使用GRU模型进行时间序列预测的Python代码示例: ```python import torch import torch.nn as nn import numpy as np import pandas as pd import matplotlib.pyplot as plt # 加载数据 data = pd.read_csv('data.csv', header=None) data = data.values.astype('float32') # 划分训练集和测试集 train_size = int(len(data) * 0.7) train_data = d

vmware12安装配置虚拟机

如何配置vmware12的“首选项”,"虚拟网络编辑器","端口映射”,"让虚拟机连接到外网”

松散事务级模型的并行标准兼容SystemC仿真

松散事务级模型的并行标准兼容SystemC仿真