la comunicación de red basadas en Java y diez multithreading

java comunicación de red

Los conceptos básicos de la comunicación de red:

Comunicación : es decir, de un software en una máquina transmite los datos a un software a otro equipo de
software a los datos de transmisión: se hace referencia como cliente de
software de recibir pasivamente los datos **: llamada del servidor **
la IP : IP en el Internet que identifica de forma exclusiva un ordenador, es un identificador único para cada equipo (documento de identidad), y programación de la red es la comunicación con el equipo remoto, por lo que debe ser capaz de localizar el equipo remoto;
puerto : IP para ayudar a resolver el problema, una puede haber muchos ordenadores en el proceso, el proceso específico y que se comunica, que se basan en el puerto de identificar;

ServerSocket 和 Socket

Enchufe

socket permite que una aplicación para leer y escribir datos desde la red, dos aplicaciones en diferentes equipos puede enviar y recibir conexión de flujo de bytes, cuando se envía un mensaje, tiene que conocerse de IP y el puerto en Java, Se refiere a una toma de java.net.Socket clase.

Socket constructor
Socket (InetAddress dirección, puerto int) Crea un socket de flujo y lo conecta con el número de puerto especificado especificado dirección IP. host para un nombre de equipo remoto o la dirección IP, el puerto es el número de puerto.
Si el servidor de conexión local, que es el número de puerto 8080, puede escribirse en el formato siguiente
new Socket(“localhost”, 8080)；
127.0.0.1 "también representa la IP local

Importante API del zócalo:
　　usando tres métodos más frecuentemente

• El accept () para la generación de "bloqueo", hasta que se recibe una conexión, y vuelve Socket instancia de objeto de un cliente. "Bloqueo" es un término que se ejecuta el programa temporalmente "aparcado" en este lugar, hasta que se genera una sesión, y el programa continúa.
• la getInputStream () para obtener una conexión de red de entrada, y devuelve un IntputStream instancia de objeto.
• la getOutputStream () será conectado al otro extremo de la entrada, y devuelve una instancia de objeto OutputStream.
  NOTA: El flujo de salida de dos flujos de entrada puede ser empaquetado y bufferoutputstream bufferinputstream
  Nota: en la que getOutputStream getInputStream y métodos producirán un IOException, que deben ser capturados, ya que vuelven objeto de secuencia, por lo general utilizado por otro objeto de secuencia.

ServerSocket

clase Socket representa un socket de cliente, es decir, en cualquier momento conectado a la toma cuando sea necesario para construir una aplicación de servidor remoto. Ahora, para implementar una aplicación de servidor requiere un enfoque diferente. necesidades servidor de reserva, porque no saben cuándo va a enviar al cliente a solicitud en este momento, tenemos que utilizar ServerSocket, corresponde clase java.net.ServerSocket.
　　Socket y diferente ServerSocket, ServerSocket está a la espera de peticiones de los clientes, una vez que una solicitud de conexión, crea un socket ejemplo para comunicarse con el cliente.
　　constructor ServerSocket
inicia un servidor de socket (en funcionamiento esencia del sistema es registrar un número de puerto), el número de puerto no debe superar los 65.535
ServerSocket ss = new ServerSocket(1999);

Si, posteriormente, la adición de un parámetro a la conexión de longitud cola de solicitudes está ajustado a 3. Esto significa que cuando la cola tiene tres solicitudes de conexión, y luego, si el cliente solicita una conexión, ésta será rechazada servidor, debido a que la cola del servidor está lleno. Utilizamos serverSocket.accept () de la solicitud de conexión se elimina de la cola.

`ServerSocket ss = new ServerSocket(1999，3);` 

el servidor

Paso servidor recibe cliente solicita
un servidor para establecer la comunicación ServerSocket
2 servidor de socket recibe el cliente para establecer un establecimiento de la conexión
3IO lee el flujo de entrada de datos enviados desde el cliente para establecer
un flujo de clientes 4io antes del envío de mensajes de datos de
códigos

package sockdemo;



import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServiceDemo {
	public static void main(String[] args) throws Exception {
	
			创建一个服务器端 Socket,即 Serversocket,指定绑定的端口,并监听此端口(本质就是向操作系统注册一个端口号)
			ServerSocket ss = new ServerSocket(1999);  
			System.out.println("启动服务器");
			
			
			// 调用 accept()方法开始监听,等待客户端的连接
			Socket sc = ss.accept();
			/**
			 * 从连接中接收数据
			 */获取IO输入流
			InputStream in =  sc.getInputStream();
			
			// 从输入流中拿数据
			
			byte[] b = new byte[1024];
			int num = in.read(b);
			String string = new String(b,0,num);
			System.out.println("收到客户端的消息：" + string);
			
			
			/**
			 * 当接受到连接后,则可以向客户端发送数据
			 */
			 //获取IO输出流
			OutputStream out = sc.getOutputStream();
			//从IO流输出数据
			out.write("我是红红".getBytes());
			//关闭输出流输入流还有连接
			out.close();
			in.close();
			sc.close();
			
}
}

cliente

El cliente envía una solicitud al servidor se puede dividir en los siguientes pasos:
　　1. Crear una instancia de Socket, ajustes de IP y un puerto de comunicación
　　2. El uso corriente de E / S para comunicarse con el servidor
　　3. Cerrar el socket

package sockdemo;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;


public class ClientDemo {
	public static void main(String[] args) throws Exception {
        // 创建 Socket通信,设置通信服务器的IP和Port
		Socket sc = new Socket("127.0.0.1", 1999);            
		
		/**
		 * 发送数据
		 */
		//获取输出流
		OutputStream out =  sc.getOutputStream();
		//发出数据
		out.write("who are you?".getBytes());
		
		/**
		 * 接收数据
		 */
		 获取输入流
		InputStream in =  sc.getInputStream();
		接受数据
		byte[] b = new byte[10];
		int num = in.read(b);
		System.out.println(new String(b,0,num));
		
		
		in.close();
		out.close();
		sc.close();
	}

}

Transformado en el servidor permanente

package cn.edu360.javase24.day13.socketdemo3;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo3 {

	public static void main(String[] args) throws Exception {

		ServerSocket ss = new ServerSocket(8080);
		int i = 1;
		while(true) {
			
			Socket sc = ss.accept();
			System.out.println("获得第"+i+"次连接了.....");
			
			InputStream in = sc.getInputStream();
			OutputStream out = sc.getOutputStream();
			
			// 收客户端的第一个问题
			byte[] b = new byte[1024];
			int num = in.read(b);
			System.out.println("收到客户端的第1个问题： " + new String(b,0,num));
			
			// 回答第一个问题
			out.write("我是宇宙无敌大美男".getBytes());
			
			
			// 接收第二个问题
			num = in.read(b);
			System.out.println("收到客户端的第2个问题： " + new String(b,0,num));
			
			
			// 回答第2个问题
			out.write("我的理想女友是按住拉败笔".getBytes());
			
			in.close();
			out.close();
			sc.close();
			i++;
		}
		
	}

}

multihilo

En primer lugar, ¿qué es multihilo? ¿Por qué utilizar múltiples hilos?

Antes de la introducción de multi-threading para introducir un hilo, el hilo es inseparable del proceso de introducción.

En primer proceso: un programa en ejecución, realiza cada proceso tiene una orden de ejecución, la orden de ejecución es un camino, o una unidad de control de llamada;

Tema: La unidad de control es un proceso separado, de control del hilo el proceso de ejecución. Un proceso en el que al menos un proceso.

Multithreading: no sólo un hilo en un proceso.

¿Por qué utilizar varios subprocesos:

①, con el fin de utilizar mejor los recursos de la CPU, si sólo hay un hilo, la segunda tarea debe esperar hasta después del final de la primera tarea, si utiliza varios subprocesos para realizar tareas en el hilo principal puede realizar otras tareas al mismo tiempo, mientras no es necesario esperar;

No se pueden compartir datos entre ②, los procesos, las discusiones pueden;

③, las necesidades del sistema para crear un proceso de re-asignar recursos del sistema para el proceso, el coste de la creación de un hilo es relativamente pequeña;

④, lenguaje Java soporte integrado para las capacidades multi-threading, lo que simplifica la programación Java multiproceso.

En segundo lugar, el hilo del ciclo de vida:

Nuevo: a partir de un nuevo objeto de roscas en el estado de inicio de programa entre las roscas (), es el nuevo estado;
Listo: objeto hilo llama al método start () después, se encuentra en un estado preparado, hasta que el programador JVM hilo planificador;
ejecute: hilo en el estado preparado en la adquisición de recursos de la CPU se puede realizar después de la carrera (), esta vez se está ejecutando el hilo, el hilo podría estar listo para ejecutar el estado, la obstrucción y la muerte tres estados.
En espera / bloqueo / reposo: En un sueño se ejecuta hilo (sueño), suspender (pendiente), etc. comparten métodos perder algunos recursos para entrar en el estado bloqueado, puede volver a entrar en el estado listo a finales de sueño.
Cambia a un estado otra condición de terminación se termina después el método run () se haya completado o la ocurrencia de: terminación.

Multi-hilo

• Tetralogía escribir programas multihilo
• 1, tendrá que utilizar una manera lógica de ejecución multi-roscado, un instrumento de escritura de clase ejecutable (método de ejecución);
• 2, crear runnable lograr esta clase de objeto;
• 3, el objeto construido mediante el uso de la rosca n-runnable el hilo;
• 4, n número de estos comienzo de la rosca (hilo.start ());

código demuestra

clase de implementación presentación escrita del ejecutable

package cn.edu360.javase24.day13.thread.demo1;

public class Demo1 implements Runnable {
	private String name;
	
	public Demo1(String name) {            
		this.name = name;
	}
	
	
	public void setName(String name) {          //可以通过这个方法向类中输入参数
		this.name = name;
	}

	@Override 　　　               //将线程要运行的代码放在该run方法中。
	public void run() {                                      
		for (int i = 0; i < 6; i++) {                  
			System.out.println("啊....."+name);
		}
		
	}

}

por

public class Demo1Test {

	public static void main(String[] args) {
		 
		Demo1 demo11 = new Demo1("张三");
		 
		Demo1 demo12 = new Demo1("李四");
		
		Demo1 demo13 = new Demo1("王五");
		
		
		
		Demo2 demo2 = new Demo2();
		//demo1.run();  // 这样调，只是用单线程普通地执行一下这个run方法而已
		
		// 构造一个线程，指定要执行的逻辑，利用这个runnable对象构造出n个thread线程；

		Thread thread1 = new Thread(demo11);
		Thread thread2 = new Thread(demo12);
		Thread thread3 = new Thread(demo13);
		Thread thread4 = new Thread(demo2);
		Thread thread5 = new Thread(demo2);
		
		// 这种调用，只是按顺序进行普通的方法调用，是在一个单线程中挨个执行的
		/*thread1.run();
		thread2.run();
		thread3.run();
		thread4.run();
		thread5.run();*/
		
		// 将这5个线程以多线程的方式同时运行
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
		thread5.start();
		
	}

transformación permanente a través del servidor multi-roscado

package cn.edu360.javase24.day13.thread.demo2;

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 将对话服务器改造成多线程服务
 * @author ThinkPad
 *
 */
public class ThreadServerDemo {

	public static void main(String[] args) throws Exception {

		ServerSocket ss = new ServerSocket(10000);
		int i=1;
		while (true) {
			
			Socket sc = ss.accept();
			System.out.println("收到连接"+i);
			Talk talk = new Talk(sc);
			new Thread(talk).start();
			i++;

		}

	}

}

Incluso hablar clase de interfaz Ejecutable

package cn.edu360.javase24.day13.thread.demo2;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;


/**
 * 用来封装线程中要执行的 对话逻辑（对话流程）
 * @author ThinkPad
 *
 */
public class Talk implements Runnable {
	Socket sc;

	public Talk(Socket sc) {
		this.sc = sc;
	}

	@Override
	public void run() {
		try {
			// 获取输入、输出流
			InputStream in = sc.getInputStream();
			OutputStream out = sc.getOutputStream();
			
			//收第一个问题
			byte[] b = new byte[1024];
			int num = in.read(b);
			System.out.println("收到客户端的问题1：" + new String(b,0,num));
			
			// 回复第一个问题
			out.write("我是宇宙无敌超级美少女战士".getBytes());
			
			// 接收第二个问题
			num = in.read(b);
			System.out.println("收到客户端的问题2：" + new String(b,0,num));
			
			// 回复第二个问题
			out.write("我18岁".getBytes());
			
			
			in.close();
			out.close();
			sc.close();

		} catch (Exception e) {
			System.out.println("发生异常了.......");
		}