Java线程及TCP编程

线程

进程由线程组成，多线程可以实现多个任务的同时运行，是网络编程的必要一环

普通线程

class Mythread implements Runnable{
    private String name;
    public Mythread(String nn){
        this.name=nn;//对象标识
    }

    @Override
    public void run() {
        //启动线程后自动执行的内容
        for(int i=0;i<100;i++) {
            try {
                Thread.sleep(200);
                System.out.println(name+"===>"+i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }        
}

public class Main{
    public static void main(String[] args) {
        Thread t1=new Thread(new Mythread("A"));//创建线程对象1
        Thread t2=new Thread(new Mythread("B"));//创建线程对象2
        t1.start();//启动线程
        t2.start();
    }
}

匿名线程

public class Main{
    public static void main(String[] args) {
        //匿名线程-----------
        new Thread() {
          public void run() {
            //启动线程后自动执行的内容
            for(int i=0;i<100;i++) {
                try {
                Thread.sleep(200);
                System.out.println("===>"+i);
                } catch (InterruptedException e) {
                e.printStackTrace();
                 }
            }
         }
        }.start();//启动
    }
}

TCP编程

TCP客户端
连接服务器，可以实现连接错误判断、接收错误判断、服务器关闭判断

import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
class MySocket{
    private Socket sock;
    private InputStream reader;
    private PrintWriter writer;    
    private boolean Runtobool;
    //启动socket客户端
    public MySocket() {
        //连接socket
        try{
        sock=new Socket("192.168.2.110",8001);
        writer=new PrintWriter(new OutputStreamWriter(sock.getOutputStream()));//获取输出流
        reader=sock.getInputStream();//获取输入流//获取输入流
        //写数据，发送数据
        writer.write("-东小东-");
        writer.flush();
        //开始读数据
        Runtobool=true;
        startServ();
        }catch(Exception e){
            Runtobool=false;
            System.out.println("open socket err");
        }    
    }
    //接收数据函数
    public void startServ(){
        //匿名线程
        new Thread(){
        public void run(){
        try{
        //接收缓冲区
        byte[] bytes = new byte[1024]; 
        while(Runtobool){
        //接收函数，此函数会阻塞
        while((reader.read(bytes, 0, bytes.length))!=-1){
            String datax=new String(bytes,"gbk");
            System.out.println("收到数据:"+datax);
            bytes = new byte[1024];//清空数组的内容，必须
        }
        //接收为空时进入
        System.out.println("server break err");
        Runtobool=false;
        }
        }catch(Exception e){
            Runtobool=false;
            System.out.println("rev socket err");
        }}
       }.start();
    }
}
public class Main{
    public static void main(String[] args) {
        new MySocket();
    }
}

TCP服务器
实现单个客户端接入

import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
class MySocket{
    private ServerSocket sockser;
    private Socket sock;
    private InputStream reader;
    private PrintWriter writer;    
    private boolean Runtobool;
    //启动socket客户端
    public MySocket() {
        //连接socket
        try{
        sockser=new ServerSocket(8001);//监听端口8001
        sock=sockser.accept();//阻塞等待客户接入
        writer=new PrintWriter(new OutputStreamWriter(sock.getOutputStream()));//获取输出流
        reader=sock.getInputStream();//获取输入流//获取输入流
        //写数据，发送数据
        writer.write("-东小东-");
        writer.flush();
        //开始读数据
        Runtobool=true;
        startServ();
        }catch(Exception e){
            Runtobool=false;
            System.out.println("open socket err");
        }    
    }
    //接收数据函数
    public void startServ(){
        //匿名线程
        new Thread(){
        public void run(){
        try{
        //接收缓冲区
        byte[] bytes = new byte[1024]; 
        while(Runtobool){
        //接收函数，此函数会阻塞
        while((reader.read(bytes, 0, bytes.length))!=-1){
            String datax=new String(bytes,"gbk");
            System.out.println(sock.getRemoteSocketAddress()+"==>收到数据:"+datax);
            bytes = new byte[1024];//清空数组的内容，必须
        }
        //接收为空时进入
        System.out.println("client server break err");
        Runtobool=false;
        }
        }catch(Exception e){
            Runtobool=false;
            System.out.println("rev socket err");
        }}
       }.start();
    }
}
public class Main{
    public static void main(String[] args) {
        new MySocket();
    }
}

TCP服务器改进版
可同时接收多个连接

import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
class MySocket{
    //启动socket客户端
    public MySocket() {
        //匿名线程
        new Thread(){
        public void run(){
        //连接socket
        try{
        ServerSocket sockser=new ServerSocket(8001);//监听端口8001
        while(true) {
         Socket sock=sockser.accept();//阻塞等待客户接入
         startServ(sock);
        }
        }catch(Exception e){
            System.out.println("open socket err");
          }
        }
        }.start();
    }
    //接收数据函数
    public void startServ(Socket sock){
        try {
            PrintWriter writer=new PrintWriter(new OutputStreamWriter(sock.getOutputStream()));//获取输出流
            InputStream reader=sock.getInputStream();//获取输入流//获取输入流
            //写数据，发送数据
            writer.write("-东小东-");
            writer.flush();
            //匿名线程
            new Thread(){
            public void run(){
            boolean Runtobool=true;    
            try{
            //接收缓冲区
            byte[] bytes = new byte[1024];
            while(Runtobool){
            //接收函数，此函数会阻塞
            while((reader.read(bytes, 0, bytes.length))!=-1){
                String datax=new String(bytes,"gbk");
                System.out.println(sock.getRemoteSocketAddress()+"==>收到数据:"+datax);
                bytes = new byte[1024];//清空数组的内容，必须
            }
            //接收为空时进入
            System.out.println("client server break err");
            Runtobool=false;
            }
            }catch(Exception e){
                Runtobool=false;
                System.out.println("rev socket err");
            }}
           }.start();            

        }catch(Exception e) {
            System.out.println("异常-----");
        }
    }
}
public class Main{
    public static void main(String[] args) {
        new MySocket();
    }
}