多线程与网络编程

Java张金贺

已于 2022-07-15 15:09:08 修改

阅读量609

点赞数

分类专栏： CJava 文章标签： java

于 2022-07-08 15:44:04 首次发布

本文链接：https://blog.csdn.net/weixin_47281685/article/details/125650980

版权

CJava 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

一、网络协议

应用层 HTTP、FTP、TFTP、SMTP、SNMP、DNS

传输层 TCP、UDP

网络层 ICMP、IGMP、IP、ARP、RARP

数据链路层由底层网络定义的协议

物理层由底层网络定义的协议

二、TCP与UDP

（一）UDP

用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。由于使用UDP 协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

（二）TCP

传输控制协议(Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

三次握手:TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

第―次握手，客户端向服务器端发出连接请求，等待服务器确认。

第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。

第三次握手，客户端再次向服务器端发送确认信息，确认连接。

1.TCP传输数据

客户端套接字Socket

服务端套接字ServerSocket

传输过程：（注意:服务端是没有IO流的，所以要使用客户端的输入流）

（1）服务端创建一个套接字对象ServerSocket server=new ServerSocket(6000) ;

（2）服务端监听客户端的连接Server. accept();返回连接它的客户端的套接字对象。

（3）客户端创建套接字对象Socket s = new Socket("服务端",6000) ;

（4）客户端获取到套接字对象的输出流s.getoutputStream() ;

（5）客户端输出数据

（6）服务端获取客户端套接字的输入流s.getInputStream();

（7）服务端接收数据

2.代码实现

启动顺序：先服务端，后客户端！

package net.demo;

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

/**
 * @Author:张金贺
 * @Date：2022/7/8 10:02
 * @Version 1.0
 */
public class server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动");
        //创建套接对象
        ServerSocket server =new ServerSocket(6000);
        //监听客户端
        Socket client = server.accept();
        //获取客户端套接字的输入流
        InputStream input = client.getInputStream();
        //接收数据
        byte[] b=new byte[1024];
        int len = input.read(b);
        System.out.println(new String(b,len));
        client.close();
        server.close();
    }
}

package net.demo;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

/**
 * @Author:张金贺
 * @Date：2022/7/8 10:06
 * @Version 1.0
 */
public class client {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        //创建套接对象
        Socket client =new Socket("localhost",6000);
        //获取套接字对象的输出流
        OutputStream out =client.getOutputStream();
        //输出数据
        out.write("hello".getBytes());
        client.close();
    }
}

三、网络编程三要素

（一）协议

计算机网络通信必须遵守的规则。

（二）IP

互联网协议地址。

1.IPV4

IPv4:是一个32位的二进制数，通常被分为4个字节,，表示成a.b.c.d的形式，例如192.168.65.100。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。

2.IPV6

IPv6:由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

3.常用命令

查看本机ip：ipconfig

检查网络是否连通：ping 空格 IP地址

特殊的IP地址：本机127.0.0.1、localhost

端口号：每个应用程序都会对应一个端口号。用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。
利用协议+IP地址+端口号三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

四、案例

（一）上传文件

package net.demo1;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author:张金贺
 * @Date：2022/7/8 10:15
 * @Version 1.0
 */
public class server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动");
        //获取网络输入流
        ServerSocket server= new ServerSocket(6000);
        while (true){
            Socket client = server.accept() ; //监听客户端
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //创建一个本地输出流
                    try{
                    BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(System.currentTimeMillis()+".jpg"));
                    BufferedInputStream bis = new BufferedInputStream(client.getInputStream());//获取网络输入流
                    byte[] b = new byte[1024*8];
                    int len;
                    while((len=bis.read(b))!=-1) {
                        bos.write(b, 0, len);
                    }
                    bis.close();
                    bos.close();
                    // server.close();
                    client.close();
                    System.out.println("保存完毕");
                    }catch (IOException e){
                        System.out.println(e);
                    }
                }
            }).start();

       }
    }
}

package net.demo1;

import java.io.*;
import java.net.Socket;

/**
 * @Author:张金贺
 * @Date：2022/7/8 10:23
 * @Version 1.0
 */
public class client {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        //创建本地输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        //获取网络输出流
        Socket socket = new Socket("localhost", 6000);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        byte[] b = new byte[1024*8];
        int len;
        while((len=bis.read(b))!=-1) {
            bos.write(b, 0, len);
            bos.flush();
        }
            socket.close();
            bis.close();
            bos.close();
    }
}

服务端发送反馈

while((len=bis.read(b))!=-1) {
    bos.write(b, 0, len);
}

//获取网络输出流
OutputStream out = client.getOutputStream();
out.write("文件上传成功! ".getBytes() );
out.close();

bis.close();
bos.close();

------------------------------------------------------------------------------

while((len=bis.read(b))!=-1) {
    bos.write(b, 0, len);
    bos.flush();
}

//关闭输出流通知服务端已经上传完毕
socket.shutdownOutput() ;
//获取输入流
InputStream input = socket.getInputStream();
//获取服务端发送过来的响应信息.并打印
byte[] b1 = new byte[1024];
input.read(b1);
System. out.println(new String(b1)) ;
input.close();

    socket.close();
    bis.close();

（二）模拟BS服务器

package net;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

import static java.lang.System.out;

/**
 * @Author:张金贺
 * @Date：2022/7/8 10:57
 * @Version 1.0
 */
public class WEBserver {
    public static void main(String[] args) throws IOException {
        //创建套接对象
        ServerSocket server = new ServerSocket(8080);
       while (true){
        //监听客户端
        Socket client = server.accept();
        //获取客户端套接字的输入流
//        InputStream input = client.getInputStream();
//        //接收数据
//        byte[] b = new byte[1024];
//        int len;
//        while ((len=input.read(b))!=-1){
//            System.out.println(new String(b,0,len));
//        }
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                   BufferedReader reader=new BufferedReader(new InputStreamReader(client.getInputStream()));
                   String str = reader.readLine();//读取第一行数据
                   String path = str.split(" ")[1].substring(1);
                   System.out.println(path);

                   //读取浏览器访间的页面
                   FileInputStream inputStream = new FileInputStream(path);
                   byte[] by = new byte[1024];
                   int len1;
                   //获取网络输出流
                   OutputStream out = client.getOutputStream();

                   //写入HTTF协议响应头,固定写法
                   out.write("HTTP/1.1 200 0K\r\n".getBytes());
                   out.write("Content-Type:text/html\r\n".getBytes());
                   //必须要写入空行,否则浏览器不解析
                   out.write("\r\n".getBytes());

                   while ((len1=inputStream.read(by))!=-1){
                       out.write(by,0,len1);
                   }
                   inputStream.close();
                   out.close();
                   reader.close();
                   client.close();
                   // server.close();
                   }catch (IOException e){
                       out.println(e);
                   }
               }
           }).start();

       }
    }
}

五、并发和并行

并发:指两个或多个事件在同一个时问段内发生（交替发生）。

并行:指两个或多个事件在同一时刻发生(同时发生)。

六、进程和线程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程:线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个钱程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 jvm帮我们开启的从应用程序到cpu的执行路径。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

（一）多线程

单核:cpu在n个线程中间快速的来回切换。
多核多线程(4核八线程):八个线程在n个线程之间切换，效率提高8倍。

多线程的好处:1.提高效率。2.线程之间彼此独立不相互影响。

（二）创建多线程

分时调度：
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
抢占式调度：
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的为抢占式调度。

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是 Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程。

1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2.创建Threa手类的实例，即创建了线程对象。
3.调用线程对象的start()方法来启动该线程。

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 11:37
 * @Version 1.0
 */
public class demo02 extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 10000; i++) {
            System.out.println("子线程"+i);
        }
    }
}

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 11:40
 * @Version 1.0
 */
public class demo03 {
    public static void main(String[] args) {
        demo02 th=new demo02();//创建线程对对象
        th.start();//启动线程
        for (int i = 0; i < 10000; i++) {
            System.out.println("主线程"+i);
        }
    }
}

1.多线程练习

编写一个多线程程序,实现两个线程,线程1每间隔1秒输出Hello，线程2每间隔2秒输出Hi。

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 11:48
 * @Version 1.0
 */
public class demo000 {
        public static void main(String[] args) {
            Thread thread = new Thread(new H1());
            Thread thread1 = new Thread(new H2());
            thread.start();
            thread1.start();
        }


    static class H1 implements Runnable{
        @Override
        public void run() {
            while(true) {
                System.out.println("Hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class H2 implements Runnable{
        @Override
        public void run() {
            while(true) {
                System.out.println("Hi");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.实现Runable接口创建多线程

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 11:55
 * @Version 1.0
 */
public class demo04 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 11:56
 * @Version 1.0
 */

/*1.定义Runnable接口的实现类，并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。demo4
  2.创建Rurnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  3.调用线程对象的start()方法来启动线程。
  */
public class demo41 {
    public static void main(String[] args) {
        demo04 impl=new demo04();
        Thread t =new Thread(impl);
        t.start();
    }
}

3.匿名内部类创建多线程

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 12:04
 * @Version 1.0
 */
public class ni01 {
    public static void main(String[] args) {
        Runnable r= new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println("子线程");
                }
            }
        };
        Thread t=new Thread(r);
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程");
        }
    }
}

（三）线程安全问题

共享线程会出现重复等安全问题！！！

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题:
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是“葫芦娃大战奥特曼"，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖“葫芦娃大战奥特曼"这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟;需要票，Runnable接口子类
来模拟模拟票:

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 12:11
 * @Version 1.0
 */
public class piao implements Runnable{
    int count =100;
    @Override
    public void run() {
        while (true){
            if (count>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖第"+count--+"张票");
            }
        }
    }
}

package duoxiancheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 12:14
 * @Version 1.0
 */
public class piao1 {
    public static void main(String[] args) {
        piao t =new piao();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}

安全问题解决

1.同步代码块

synchronized(同步锁){
需要同步操作的代码，
}

* 同步锁--可以是任意的对象
* 所有的线程使用的需要是同一个锁

public class piao implements Runnable{
    int count =100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+count--+"张票");
                }
            }
        }
    }
}

2.同步方法

public synchronized void method(){
可能会产生线程安全问题的代码}

public synchronized void sellTicket(){
    if (count>0){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"正在卖第"+count--+"张票");
    }
}

3.锁机制

public class piao implements Runnable{
    int count =100;
    Lock lock =new ReentrantLock();//锁对象
    @Override
    public void run() {
        while (true){
            lock.lock();
                if (count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+count--+"张票");
                }
            lock.unlock();
            }
        }
    }

4.死锁

同步锁使用的弊端:当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象:程序出现无限等待，这种现象我们称为死锁。

（四）线程状态

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动。还没调用start方法。
Runnable（可运行）	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态;当该线程持有锁时，该线程将变成Runnable状态。
Timed Waiting（计时等待）	同waiting状态，有几个方法有超时参数，调用他们将进入Timed waiting状态。这—状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、object.wait。
Waiting（无限等待）	一个线程在等待另一个钱程执行一个(唤醒)动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

（五）等待唤醒机制

1.线程间的通信

多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
比如:线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

2.等待唤醒机制

这是多个线程间的—种协作机制。谈到线程我们经常想到的是线程间的竞争(race)，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就是在一个线程进行了规定操作后，就进入等待状态（ wait()），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;在有多个线程进行等待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程。

（六）生产者消费者模式

package duoxiancheng.sheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 15:13
 * @Version 1.0
 */
public class BaoZi {
    private String xianer;
    private Boolean flag;

    public BaoZi() {
    }

    public BaoZi(String xianer, Boolean flag) {
        this.xianer = xianer;
        this.flag = flag;
    }

    public String getXianer() {
        return xianer;
    }

    public void setXianer(String xianer) {
        this.xianer = xianer;
    }

    public Boolean getFlag() {
        return flag;
    }

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    @Override
    public String toString() {
        return "BaoZi{" +
                "xianer='" + xianer + '\'' +
                ", flag=" + flag +
                '}';
    }
}

package duoxiancheng.sheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 15:15
 * @Version 1.0
 */
public class ChiHuo implements Runnable{
    private  BaoZi baoZi;

    public ChiHuo(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while (true){
            synchronized (baoZi){
            if (baoZi.getFlag()==false){
                try {
                    baoZi.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
              }
                System.out.println("吃包子");
            baoZi.setFlag(false);
            baoZi.notify();//唤醒生产者线程
            }
        }
    }
}

package duoxiancheng.sheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 15:21
 * @Version 1.0
 */
public class ShengChan implements Runnable{
    private  BaoZi baoZi;
    public ShengChan(BaoZi baoZi) {
        this.baoZi = baoZi;
    }
    @Override
    public void run() {
        while (true){
            synchronized (baoZi){
                if (baoZi.getFlag()==true){
                    try {
                        baoZi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("生产包子");
                baoZi.setFlag(true);
                baoZi.notify();//唤醒吃货线程
            }
        }
    }
}

package duoxiancheng.sheng;

/**
 * @Author:张金贺
 * @Date：2022/7/8 15:24
 * @Version 1.0
 */
public class BaoZiTest {
    public static void main(String[] args) {
        BaoZi baoZi=new BaoZi("白菜",false);
        new Thread(new ShengChan(baoZi)).start();
        new Thread(new ChiHuo(baoZi)).start();
    }
}

（七）线程池

线程池其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
由于线程池中有很多操作都是与优化资源相关的，在这里就不多赘述。通过一张图来了解线程池的工作原理:

合理利用线程池能够带来三个好处:
1．降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2．提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3．提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

线程池的使用

具体见JDK中executors的用法

使用步骤：1．创建线程池对象。2．创建 Runnable 接口子类对象。(task) 3．提交Runnable 接口子类对象。(take task)4．关闭线程池(一般不做)。

public class MyRunable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

package duoxiancheng.chi;

import java.lang.reflect.Executable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author:张金贺
 * @Date：2022/7/8 15:38
 * @Version 1.0
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);//创建一个线程池对象
        service.submit(new MyRunable());//从线程池获取一个线程并执行
        service.submit(new MyRunable());//从线程池获取一个线程并执行
        service.submit(new MyRunable());//从线程池获取一个线程并执行

        service.shutdown();//线程池关闭
    }
}