day16多线程&网络编程&日志&枚举

最新推荐文章于 2023-09-09 16:48:19 发布

时砂011

最新推荐文章于 2023-09-09 16:48:19 发布

阅读量154

点赞数

分类专栏： javaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_51548021/article/details/128821120

版权

多线程&网络编程

一、实现多线程

1.1 相关概念

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的一条执行路径、实际运作单位。简单理解：应用软件中互相独立，可以同时运行的功能。我们之前编写的代码属于单线程程序。

进程是程序的基本执行实体、正在运行的程序。进程是系统进行资源分配和调用的独立单位，每个进程都有它自己的内存空间和系统资源。进程具有以下特性

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
并发性：任何进程都可以同其他进程一起并发执行。

多线程就是有多个线程的程序，它可以同时执行多个线程以提高效率，可以在一些比较耗时的操作中应用该技术。如：拷贝大文件、复制传输大文件等。聊天软件、服务器、游戏中也有大量应用。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并行：在同一时刻，有多个指令在多个CPU上同时执行。

1.2 实现方式

1.2.1 Thread类

用来表示/操作线程。在Java中创建好的Thread实例，其实和操作系统中的线程是一一对应的关系，操作系统提供了一组关于线程的API(C语言)，Thread类是Java对于这组API进一步封装。

方法介绍

方法名	说明
启动方法
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用此线程的run方法()
名称/对象相关方法	[点这里](#示例代码 1.1)
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
static Thread currentThread()	返回对当前正在执行的线程对象的引用
控制方法	[点这里](#示例代码 1.4)
static void sleep(long milis)	使当前正在执行的线程停留(暂停执行)
void join()	等待这个线程死亡
[void setDaemon(boolean on)](#示例代码 1.6)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
优先级方法	[点这里](#示例代码 1.5)
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级(线程默认优先级是5，线程优先级范围是：1-10)

给线程设置名称还有带参的构造方法Thread(String name)，使用带参构造方法需要先在继承子类中写入无参、String name参数构造方法。

public static Thread currentThread() 返回对当前正在执行的线程对象的引用

实现步骤
1. 定义一个类MyThread继承Thread类
2. 在MyThread类中重写run()方法
3. 创建MyThread类的对象
4. 启动线程

示例代码 1.1

/*MyThread类*/
public class MyThread extends Thread{
   
    MyThread() {
   
        System.out.println("Thread.currentThread()---"+Thread.currentThread().getName());  //构造方法的执行线程为main
    }
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(this.getName()+"线程开始执行了"+i);
        }
        System.out.println("Thread.currentThread()---"+Thread.currentThread().getName());  //获取线程对象，返回当前线程对象的名字
    }
}
/*测试类*/
public class MyTreadDemo {
   
    public static void main(String[] args) {
   
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.setName("线程1"); //设置线程名字
        myThread2.setName("线程2");
        myThread1.start(); //currentThread.getName == 线程1
        myThread2.start(); //currentThread.getName 此时为“线程2”
        //myThread2.run();   //直接调用run时，执行线程为main
    }
}

线程执行有每次执行都可能不同的特点，因为start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统/CPU决定的。

重写run()方法是因为它是用来封装被线程执行的代码，调用start()方法时会自动执行run()方法。

start()方法和run()方法区别：

run()方法封装线程执行的代码。直接调用时，相当于普通方法，使用currentThread方法返回线程对象为main线程；

start()方法启动线程，然后由JVM调用此线程的run方法，使用currentThread方法返回的线程对象名为对应线程名。同一个线程不能多次执行start()方法。

1.2.2 Runnable接口

由于Thread是线程类，需要将方法传入后才能执行。为了将线程和操作方法分离，Java提供了Runnable接口。Runnalbe 只是一个接口，提供了唯一一个方法 run()，可用于多线程中任务的运行定义。

Thread构造方法

Thread(Runnable target) 分配一个新的Thread对象
实现步骤
1. 定义一个类MyRunnable实现Runnable接口
2. 在MyRunnable类中重写run()方法
3. 创建MyRunnable类对象
4. 创建Thread类对象，把MyRunnable对象作为构造方法的参数
5. 启动线程

示例代码 1.2

/*MyRunnable*/
public class MyRunnable implements Runnable {
   
    @Override
    public void run() {
   
        for (int i = 0; i < 50; i++) {
   
            System.out.println(Thread.currentThread().getName() + "开动了" + i);
        }
    }
}
/*测试类*/
public class MyRunnableDemo {
   
    public static void main(String[] args) {
   
        MyRunnable mr = new MyRunnable();
        MyRunnable mr1 = new MyRunnable();
        Thread thread = new Thread(mr,"飞机");
        Thread t = new Thread(mr1,"导弹");
        thread.start();
        t.start();
    }
}

相比继承Thread类，实现Runnable接口避免了Java单继承的局限性，适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想。

1.2.3 Callable和FutureTask

继承Thread和实现Runnable接口两种方式重写run()方法都不可以直接返回结果，不适合需要返回线程执行结果的业务场景。

Callable是一个函数式接口，Callable接口接受一个泛型作为接口中call方法的返回值类型。

FutureTask可以把Callable对象封装成线程任务对象以交给Thread处理，线程执行后可以通过FutureTask的get方法去获取任务执行的结果。

方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个FutureTask，一旦运行就执行给定的Callable
V get()	如有必要，等待计算完成并获取结果

实现步骤
1. 定义一个MyCallable类实现Callable接口
2. 在MyCallable类中重写call()方法
3. 创建MyCallable类对象
4. 创建FutureTask对象，把MyCallable对象作为构造方法的参数
5. 创建Thread类的对象，把FutureTask对象作为构造方法的参数
6. 启动线程
7. 再调用get方法，就可以获取线程结束后的结果。
注意事项

get()方法的调用一定要在Thread类的对象调用start()方法之后

示例代码 1.3

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author Lenovo
 */
public class MyCallable implements Callable<String> {
   
    @Override
    public String call() throws Exception {
   
        for (int i = 0; i < 10; i++) {
   
            System.out.println("跟妹子表白第" + i + "次");
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread没有直接接收Callable接口实现类对象的构造方法
        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft1 = new FutureTask<>(mc);
        FutureTask<String> ft2 = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2)

        //String s = ft.get();
        //开启线程
        t1.start();
        t2.start();

        System.out.println(ft1.get());
        System.out.println(ft2.get());
    }
}

1.2.4 Thread的[方法](#1.2.1 Thread类)

设置和获取线程名称
获取当前线程对象
线程控制(睡眠和等待)

示例代码 1.4

public class ThreadDemo {
   
    public static void main(String[] args) {
   
        MYThread myThread1 = new MYThread();
        MYThread myThread2 = new MYThread();

        myThread1.setName("烧水");

        myThread2.setName("泡面");

        myThread1.start(); //currentThread.getName == 线程1

        try {
   
            myThread1.join();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }

        myThread2.start(); //currentThread.getName 此时为“线程2”

    }
}
class MYThread extends Thread {
   
    MYThread() {
    }
    @Override
    public void run() {
   
        for (int i = 0; i < 30; i++) {
   
            System.out.println(this.getName() + "开始执行了"+i);
        }
//        try {
   
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
   
//            e.printStackTrace();
//        }
        System.out.println("Thread.currentThread()---" + Thread.currentThread().getName());
    }
}

线程优先级

线程调度模型
- 分时调度模型：
  
  所有线程轮流使用CPU的使用权，平均分配给每个线程占用CPU的时间片。
- 抢占式调度模型：
  
  优先让优先极高的线程使用CPU,如果线程的优先级相同，那么会随机选择一个，优先级搞得线程获取的CPU时间片相对多一些。
线程默认优先级是5，范围为1~10的int类型整数，最高为10最低为1。线程优先级高仅仅代表线程获取CPU时间片的几率高，不代表他一定优先完成。

示例代码 1.5

public class ThreadDemo {
   
    public static void main(String[] args) {
   
        MYThread myThread1 = new MYThread();
        MYThread myThread2 = new MYThread();

        myThread1.setName("汽车");
        myThread1.setPriority(1);
        myThread2.setName("飞机");
        myThread2.setPriority(10);

        myThread1.start(); //currentThread.getName == 线程1
        myThread2.start(); //currentThread.getName 此时为“线程2”

    }
}

class MYThread extends Thread {
   
    MYThread() {
    }
    @Override
    public void run() {
   
        for (int i = 0; i < 30; i++) {
   
            System.out.println(this.getName() + "开始执行了" + i);
        }
        System.out.println("Thread.currentThread()---" + Thread.currentThread().getName());
    }
}

守护线程

示例代码 1.6

public class ThreadDemo {
   
    public static void main(String[] args) {
   
        MYThread myThread1 = new MYThread();
        MYThread myThread2 = new MYThread();

        myThread1.setName("公主");

        myThread2.setName("骑士");
        //设置守护线程
        myThread2.setDaemon(true);

        myThread1.start(); 
        myThread2.start(); 

    }
}
class MYThread extends Thread {
   
    MYThread() {
    }
    @Override
    public void run() {
   
        for (int i = 0; i < 100; i++) {
   
            System.out.println(this.getName() + "开始执行了"+i);
        }
        System.out.println(Thread.currentThread().getName()+"死了");//标记终点
    }
}

运行结果

公主开始执行了98
公主开始执行了99
骑士开始执行了87
公主死了
骑士开始执行了88
骑士开始执行了89
骑士开始执行了90  //公主死了之后骑士并未执行到终点

1.2.5 线程生命周期

创建线程对象(new Thread)
执行(start)，转为就绪状态(有执行资格但没执行权)
如果抢到执行权，开始运行
如果运行时执行权被抢走，返回就绪状态
如果运行时遇到阻塞方法，转为阻塞状态(没有执行资格和执行权)
阻塞状态结束(方法时间结束/阻塞方式结束)，返回就绪状态
如果执行完成(run结束)，线程死亡变成垃圾

小结

线程相关概念：线程是操作系统调度的最小单位，进程是程序运行的实体，多线程就是有多个线程的程序，并发就是同时有多个程序交替执行，并行就是有多个程序同时执行。

Java中有三种实现线程的方式：继承Thread类、实现Runnable接口、实现Callable接口，他们的最终实现类都是Thread。但Callable可以获取方法返回值，Thread和Runnable则不可以。Thread有设置/获取名字、返回线程对象、开始/等待/睡眠、设置/返回优先级、守护线程等方法。

线程自创建开始进入生命周期，线程对象调用start方法开启第二个周期，线程转为就绪状态，如果此时抢到执行权就开始运行，若没有或运行时执行权被抢走就转为就绪状态，如果运行时遇到阻塞方法则转为阻塞状态，阻塞状态结束返回就绪状态，执行完成run方法体内部代码后线程死亡。

二、线程同步

2.1 线程的安全问题

2.1.1 卖票案例

需求：有100张票，有三个窗口卖票，请设计一个程序模拟卖票。

/*SellTicket*/
public class SellTicket implements Runnable {
   
    private int tickets = 100;

    @Override
    public void run() {
   
        while (true) {
   
            if (tickets > 0) {
   
                try {
   
                    Thread.sleep(100); //模拟出票动作
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + 
                                   "售出第" + tickets);
                tickets--;  //卖出后票数-1
                System.out.println("余票" + tickets + "张"); //显示余票

            } else {
   
                System.out.println("票没了");
                try {
   
                    Thread.sleep(10000);  //模拟隔不久就有人来买票
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        }
    }
}
/*测试类*/
public class SellTicketDemo {
   
    public static void main(String[] args) {
   
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");


        t1.start();
        t2.start();
        t3.start();
        
        /*
        窗口2售出第97
		余票96张
		窗口2售出第96
		余票95张
		窗口1售出第96
		余票95张
        */
        //由于线程具有随机性，多个线程操作一个数据源时会造成线程安全问题
    }
}

2.1.2 出现线程安全问题原因

是否是多线程环境
是否有共享数据
是否有多条语句操作共享数据

当以上三个条件同时出现，就会导致线程安全问题，解决方法为：把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可。方式有：同步代码块、同步方法

一个线程只能有锁的时候才能对共享数据进项访问，结束访问后必须释放锁。

持有锁和释放锁之间所执行的代码叫做临界区(Critical Section)

锁具有排他性，即一个锁只能被一个线程持有，这种锁被称为互斥锁

2.1.3 同步代码块

格式

synchronized(任意对象){
     
    多条语句操作共享数据的代码
}

优势劣势
- 优势：解决了多线程的数据安全问题
- 劣势：当线程很多时，每个线程都会判断同步上的锁，会降低程序的运行效率。

锁对象需要唯一，如果不同线程锁的不是同一个对象，就解决不了线程安全的问题，所以synchronized后的对象不能为this。

示例代码 2.1

/*SellTicket类*/
public class SellTicket implements Runnable {
   
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
   
        while (true) {
   
            //假设t1先抢到执行权，t1进入run，遇到sychronized将自身锁入
            synchronized (obj){
   
                if (tickets > 0) {
   
                    try {
   
                        //t1 休眠，但仍占用锁
                        Thread.sleep(100);
                        //假设此时t2进入，但t1被锁在里面，t2无法执行锁内代码块
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                    //t1休眠结束，继续执行
                    System.out.println(Thread.currentThread().getName() + "售出第" + tickets);
                    tickets--;
                } else {
   
                    System.out.println("票没了");
                    try {
   
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
/*测试类*/
public class SellTicketDemo {
   
    public static void main(String[] args) {
   
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");


        t1.start();
        t2.start();
        t3.start();
    }
}
/*
窗口3售出第10
窗口3售出第9
窗口2售出第8
窗口2售出第7
窗口1售出第6
窗口1售出第5
窗口1售出第4
窗口1售出第3
窗口1售出第2
窗口1售出第1
票没了
*/

2.1.4 同步方法

同步方法就是将synchronized加到方法上。

格式

修饰符 synchronized 返回值类型 方法名(参数){
     
    方法代码块
}

同步方法的锁对象是this

静态同步方法

就是将synchronized加到静态方法上

静态同步方法的锁对象是类名.class

示例代码 2.2

public class SellTicket implements Runnable {
   
    private static int tickets = 100;

    @Override
    public void run() {
   
        while (true)<