Java中的线程和网络

客官°小女子只卖身不卖艺 2023-10-12 16:43 4阅读 0赞

## 1.多线程 ##

### 1.1 线程概述 ###

**进程和线程**

**进程：**应用程序的执行实例（一个应用对应一个进程）

**线程：**CPU调度和分派的基本单位,进程中执行运算的最小单位

### 1.2 创建线程 ###

#### 1.2.1 创建线程的种类 ####

在Java中创建线程的两种方式①继承java.lang.Thread类②实现java.lang.Runnable接口。

#### 1.2.2 继承Thread类创建线程 ####

**步骤：**

**（1）定义MyThread类继承Thread类  
（2）重写run()方法，编写线程执行体  
（3）创建线程对象，调用start()方法启动线程**

**单线程：**

public class MyThread extends Thread {
        //继承Thread类并重写run()方法
        public void run(){
            for (int i = 0; i < 10; i++) {
                //打印输出i和线程名
                System.out.println(i+" 线程名："+Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            //创建自定义线程对象
            MyThread myThread = new MyThread();
            //调用start()方法
            myThread.start();
        }
    }

![6ca440c5e64a4ae69c09e079ff518648.png][]

**多线程：**

public class MyThread extends Thread{
        public void run(){
            for (int i = 0; i < 50; i++) {
                System.out.println(i+" 线程名："+Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            MyThread1 myThread1 = new MyThread();
            MyThread1 myThread2 = new MyThread();
            myThread11.start();
            myThread12.start();
        }
    }

![80b91dd0f0e04339840eecb79dc5fc66.png][]

#### 1.2.3 实现Runnable接口创建线程 ####

步骤与上面的步骤类似，直接上代码。

**单线程：**

public class MyRunnable implements Runnable{
        //实现Runnable接口并实现run()方法
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(i + " 线程名："+Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            //创建MyRunnable的对象
            MyRunnable myRunnable = new MyRunnable();
            //创建Thread的一个对象，并使用myRunnable对象作为构造器参数
            Thread thread = new Thread(myRunnable);
            //调用thread对象的start方法
            thread.start();
        }
    }

![1d51a99649994671aa8862158daa4f3a.png][]

**多线程：**

public class MyRunnable implements Runnable{
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println(i + " 线程名："+Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) {
            MyRunnable1 myRunnable1 = new MyRunnable();
            MyRunnable1 myRunnable2 = new MyRunnable();
            Thread thread1 = new Thread(myRunnable1);
            Thread thread2 = new Thread(myRunnable2);
            thread1.start();
            thread2.start();
        }
    }

![859e5140e7d74b289b097b603af0d685.png][]

### 1.3 线程的状态 ###

#### 1.3.1 线程流程 ####

![2b063384e3984a85b42a3d0457d52f2f.png][]

**正常情况流程：**创建状态-->就绪状态-->运行状态-->死亡状态

**异常情况下流程：**创建状态-->就绪状态-->运行状态-->阻塞状态-->就绪状态-->运行状态-->死亡状态

#### 1.3.2 线程优先级 ####

线程优先级由1-10表示，1最低，默认优先级为5，优先级高的线程获得CPU资源的概率较大

![de73ac6043da48f1b41d669393870376.png][]

#### 1.3.3 线程休眠 ####

![bbd4310a86e44adfb0fefab628a9afc8.png][]

![c09b890185124f1b981608a14e05799a.png][]

### 1.4 线程安全 ###

#### 1.4.1 模拟网络抢票 ####

public class Site implements Runnable{
        private int count = 100;
        private int num = 0;
        @Override
        public void run() {
            //循环直到票被抢完
            while(true){
                if(count<=0){
                    break;
                }
                num++;
                count--;
                //模拟网络延时
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //输出哪个线程抢到了票
                System.out.println(Thread.currentThread().getName()
                        +"抢到了第"+num+"张票，还剩余"+count+"张票\n");
            }
        }
    }

public class Test {
        public static void main(String[] args) {
            Site site = new Site();
            Thread thread1 = new Thread(site);
            Thread thread2 = new Thread(site);
            Thread thread3 = new Thread(site);
            //设置一下线程名称
            thread1.setName("小张");
            thread2.setName("小李");
            thread3.setName("小王");
            System.out.println("**********************");
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

![922d1f1f140247c2892cc5816304bbd3.png][]

#### 1.4.2 线程锁synchronized ####

synchronized可以保证线程安全，但这种方式只能保证单个服务器的线程安全，多服务器集群无法保证在，需要用到另外的方法。

![e85140d04cc04f1596bfd33810f187fb.png][]

## 2.网络 ##

### 2.1 网络概述 ###

#### 2.1.1 网络定义 ####

网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。提取一下关键字①多台相互连接的计算机②通信协议③资源共享

#### 2.1.2 网络类型分类 ####

![b0eb5d6fed6a40ffaa4529cb939ab6f3.png][]

#### 2.1.3 网络体系结构 ####

![ca265fef7e7f4acaac5aa9bfff3dd371.png][]

### 2.2 网络通信协议 ###

#### 2.2.1 网络通信协议概述 ####

网络通信协议是在网络中不同的计算机之间进行通信而建立的规则、标准或约定的集合。在网络中，多台计算机之间通信和数据传输，必须遵循某种规约（即网络通信协议），如果不遵循则无法实现通信。

#### 2.2.2 网络通信协议种类 ####

（1）TCP协议（Transmission Control Protocol 传输控制协议）  
面向连接的、可靠的、基于字节流的传输通信协议（数据稳定，安全）

（2）UDP协议（User Datagram Protocol 用户数据报协议）  
无连接的协议，在传输数据之前，客户端和服务器并不建立和维护连接（数据不可靠，不安全）

### 2.3 Socket ###

#### 2.3.1 Socket简介 ####

通信链路的端点就被称为“套接字”（英文名Socket），Java中Socket是提供给应用程序的接口。Socket在Java中的路径在java.net包中。

#### 2.3.2 网络编程三要素 ####

**(1) IP**  
设备在网络中的地址，是唯一的标识

**(2) 端口号**  
应用程序在网络设备中的唯一的标识

**(3) 协议**  
数据信息在网络中传递的规则，例如UDP,TCP等等

### 2.4 Socket编程实例 ###

#### 2.4.1 基于UDP协议的Socket编程 ####

**发送端：**

public class SendMsg {
        public static void main(String[] args) throws IOException {
            //创建发送端DatagramSocket实例
            DatagramSocket datagramSocket = new DatagramSocket();
            //定义传输的内容
            String str = "your hat is down!";
            //传输需要转换为字节数组
            byte[] b = str.getBytes();
            //127.0.0.1表示本机地址
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
    
            //设置端口号为10086
            int port = 10086;
    
            //将文件内容，长度，ip地址，和端口号打包
            DatagramPacket dp = new DatagramPacket(b, b.length, inetAddress, port);
    
            //发送数据
            datagramSocket.send(dp);
            
            //释放流资源
            datagramSocket.close();
        }
    }

**接收端：**

import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    public class ReceiveMsg {
        public static void main(String[] args) throws IOException {
            //创建接收端DatagramSocket实例
            DatagramSocket datagramSocket = new DatagramSocket(10086);
            //定义字节数组，创建DatagramPacket实例，用于接收数据包
            byte[] b = new byte[1024];
            DatagramPacket dp = new DatagramPacket(b,b.length);
            datagramSocket.receive(dp);
            //导出接收好的数据包
            byte[] data = dp.getData();
            int length = dp.getLength();
        
            System.out.println("接收到数据："+new String(data,0,length));
            //关闭资源
            datagramSocket.close();
        }
    }

**需要先打开端口（运行ReceiveMsg），才能接受到数据的传入**

![05b995b31ee94f5fa18fa8ff8f0277b4.png][]

#### 2.4.2 基于TCP协议的Socket编程 ####

**客户端：**

public class Client {
        public static void main(String[] args) throws IOException {
            //创建客户端Socket实例，定义目标地址和端口
            Socket socket = new Socket("127.0.0.1",10086);
            //创建输出流
            OutputStream os = socket.getOutputStream();
            //输出数据
            os.write("哈哈".getBytes());
            //关闭流
            os.close();
            socket.close();
        }
    }

**服务端：**

public class Server {
        public static void main(String[] args) throws IOException {
            //创建服务端ServerSocket实例
            ServerSocket ss = new ServerSocket(10086);
            //获取服务端端口
            Socket socket = ss.accept();
            
            //获取数据流并输出到控制台
            InputStream is = socket.getInputStream();
            //套一个字符集可以读取中文字符
            InputStream isr = new InputStreamReader(is);
            int b;
            while((b = isr.read())!= -1){
                System.out.print((char)b);
            }
            //关闭资源
            isr.close();
            is.close();
            socket.close();
            ss.close();
        }
    }

![4248d5af37564883a854a40b9367885c.png][]

#### 2.4.3 基于TPC协议和UDP的区别 ####

![552d7ece162f4f41bdbe5880d360b9c7.png][]

[6ca440c5e64a4ae69c09e079ff518648.png]: https://img-blog.csdnimg.cn/6ca440c5e64a4ae69c09e079ff518648.png
[80b91dd0f0e04339840eecb79dc5fc66.png]: https://img-blog.csdnimg.cn/80b91dd0f0e04339840eecb79dc5fc66.png
[1d51a99649994671aa8862158daa4f3a.png]: https://img-blog.csdnimg.cn/1d51a99649994671aa8862158daa4f3a.png
[859e5140e7d74b289b097b603af0d685.png]: https://img-blog.csdnimg.cn/859e5140e7d74b289b097b603af0d685.png
[2b063384e3984a85b42a3d0457d52f2f.png]: https://img-blog.csdnimg.cn/2b063384e3984a85b42a3d0457d52f2f.png
[de73ac6043da48f1b41d669393870376.png]: https://img-blog.csdnimg.cn/de73ac6043da48f1b41d669393870376.png
[bbd4310a86e44adfb0fefab628a9afc8.png]: https://img-blog.csdnimg.cn/bbd4310a86e44adfb0fefab628a9afc8.png
[c09b890185124f1b981608a14e05799a.png]: https://img-blog.csdnimg.cn/c09b890185124f1b981608a14e05799a.png
[922d1f1f140247c2892cc5816304bbd3.png]: https://img-blog.csdnimg.cn/922d1f1f140247c2892cc5816304bbd3.png
[e85140d04cc04f1596bfd33810f187fb.png]: https://img-blog.csdnimg.cn/e85140d04cc04f1596bfd33810f187fb.png
[b0eb5d6fed6a40ffaa4529cb939ab6f3.png]: https://img-blog.csdnimg.cn/b0eb5d6fed6a40ffaa4529cb939ab6f3.png
[ca265fef7e7f4acaac5aa9bfff3dd371.png]: https://img-blog.csdnimg.cn/ca265fef7e7f4acaac5aa9bfff3dd371.png
[05b995b31ee94f5fa18fa8ff8f0277b4.png]: https://img-blog.csdnimg.cn/05b995b31ee94f5fa18fa8ff8f0277b4.png
[4248d5af37564883a854a40b9367885c.png]: https://img-blog.csdnimg.cn/4248d5af37564883a854a40b9367885c.png
[552d7ece162f4f41bdbe5880d360b9c7.png]: https://img-blog.csdnimg.cn/552d7ece162f4f41bdbe5880d360b9c7.png