java回顾——多线程

青旅半醒 2022-11-09 14:30 165阅读 0赞

## 一，问题： ##

*  什么是线程，为什么要学习它？
 *  java多线程我们要学习什么？

## 二，线程（操作系统中的概念）： ##

参考进程：[https://blog.csdn.net/weixin\_44841312/article/details/104966035][https_blog.csdn.net_weixin_44841312_article_details_104966035]

参考线程：[https://blog.csdn.net/weixin\_44841312/article/details/105191973][https_blog.csdn.net_weixin_44841312_article_details_105191973]

学习线程之前要知道：

*  **并发与并行关系**：并发指的是一段时间内多个程勋**交替运行**，并行指一段时间内多个程勋**同时运行。**
 *  **进程：**是一个程序执行的过程，是系统运行程序的基本单位。（但你启动QQ程序，本质上内存中就有了QQ这个进程）
 *  **线程：**线程是进程中的小进程，比如QQ程序中的聊天功能就是一个线程，QQ空间又是另一个线程
 *  **为什么有多线程**：为了提高进程效率（程序运行的速度）
 *  线程的调度：分时调度（轮流公平调度），抢占式调度（优先级高的可以抢CPU进行调度）

## 三，java多线程要学习什么？ ##

*  常用创建线程方法
 *  线程安全问题
 *  线程之间状态转变
 *  线程同步的代码实现
 *  线程池

## 四，开始学习： ##

### **1，常用创建线程方法：** ###

**1，继承Thread类并重写它的run方法。**（实现步骤在代码中）

*  下面people继承了Thread类，重写了run方法（该线程要执行的任务），使用people的对象p1和p1调用start方法启动两个线程。start方法会调用run方法
 *  start方法会在jvm中开辟新的栈空间，对其中的run方法压栈执行

/**
     * 实现步骤:
     * 1.创建一个Thread类的子类I
     * 2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
     * 3.创建Thread类的子类对象
     * 4.调用Thread类中的方法start方法,开启新的线程,执行run方法
     * void start() 使该线程开始执行; Java虚拟机调用该线程的run 方法。
            * 结果是两个线程并发地运行;当前线程(main线程)和另-一个线程(创建的新线程,执行其run方法)。
            * 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
            * java程序属于抢占式调度，那个线程的优先级高,那个线程优先执行;同-一个优先级,随机选择一个执行
     */
    public class RunTest {
        public static void main(String[] args) throws InterruptedException {//主线程
            People p1=new People("建江");
            People p2=new People("小明");
            p1.setName("线程1");//设置线程名称
            p1.start();//线程1
            p2.start();//线程2
            for(int i=0;i<10;i++){
                System.out.println("main"+i);
                Thread.sleep(1000);//线程睡眠1秒
            }
    
    
        }
    }

public class People extends Thread {
        private String name;
        public People(){
    
        }
        public People(String name){
            this.name=name;
        }
    
    
        @SneakyThrows
        public void run(){
            for (int i=0;i<10;i++){
                System.out.println(name+i);
                //String name = getName();//获取线程的名称
                String name = Thread.currentThread().getName();
                System.out.println("线程名称："+name);
                Thread.sleep(1000);//使得线程睡眠
            }
        }
    }

**2，实现实现Runnable接口，实现run方法（实现步骤在代码中）**

/**
     * 实现步骤:
     * 1.创建一个Runnable接口的实现类Dog
     * 2.在实现类中重写Runnable接口的run方法,设置线程任务
     * 3.创建一个Runnable接口的实现类对象
     * 4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
     * 5.调用Thread类中的start方法,开启新的线程执行run方法
     */
    public class RunTest {
        public static void main(String[] args) throws InterruptedException {//主线程
            Dog dog1=new Dog("金毛");
            Dog dog2=new Dog("泰迪");
            Thread thread1=new Thread(dog1);
            Thread thread2=new Thread(dog2);
            thread1.start();
            thread2.start();
        }
    }

public class Dog implements Runnable {
        String name;
        public Dog(){}
        public Dog(String name){
            this.name=name;
        }
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                System.out.println(name+i);
            }
        }
    }

**3，这两种创建线程的方法有什么区别（使用Runable接口实现多线程的好处）**

*  **避免了单继承的局限性：**
 *  类继承了Thread类就不能继承其他的类
 *  实现了Runnable接口,还可以继承其他的类,实现其他的接口
 *  **增强了程序的扩展性,降低了程序的耦合性(解耦)：**
 *  实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
 *  实现类中,重写了run方法;用来设置线程任务
 *  创建Thread类对象,调用start方法:用来开启新线程

**4，匿名内部类的方式创建线程**

public class RunTest {
        public static void main(String[] args){//主线程
           new Thread(){
               @Override
               public void run(){
                   for (int i=0;i<10;i++){
                       this.setName("建江");
                       System.out.println(Thread.currentThread().getName()+i);
                   }
               }
           }.start();
    
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName());
                    }
                }
            };
            new Thread(runnable).start();
    
            for (int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }

## 2，同步安全问题： ##

*  什么是同步安全问题：
 *  如何解决这个问题：同步代码块，同步方法，锁机制
 *  买票的例子（多个线程访问会出现卖重复的票，-1的票）

调用的测试方法：

public class MovieTest {
        public static void main(String[] args) {
            Movie movie=new Movie();
            Thread t1=new Thread(movie);
            Thread t2=new Thread(movie);
            Thread t3=new Thread(movie);
            t1.start();
            t2.start();
            t3.start();
    
    
        }
    }

使用同步代码块解决：

public class Movie implements Runnable {
        private Integer ticket=100;
        Object lock=new Object();//创建一个对象锁
        @Override
        public void run() {
            /**
             * lock对象只有一个，那个线程得到了lock对象，就可以执行代码块中的内容
             * 保证了对临界资源的互斥访问
             */
            
            while (true){
                synchronized (lock){//给会出现安全问题的代码加锁
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (ticket>0){
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                        ticket--;
                    }
                }
            }
    
        }}

使用同步方法解决：

public class Movie implements Runnable {
        private Integer ticket=100;
        Object lock=new Object();//创建一个对象锁
        @Override
        public void run() {
            /**
             * lock对象只有一个，那个线程得到了lock对象，就可以执行代码块中的内容
             * 保证了对临界资源的互斥访问
             */
    
            while (true){
                sellTicket();
            }
    
        }
    
        public synchronized void sellTicket(){//所对象是this
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

使用Lock机制解决：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Movie implements Runnable {
        private Integer ticket=100;
        Lock MyLock=new ReentrantLock();//创建一个获取锁的对象
        @Override
        public void run() {
            while (true){
                MyLock.lock();//上锁
                if (ticket>0){
                    try {
                        Thread.sleep(10);
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                        ticket--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        MyLock.unlock();//释放锁
                    }
    
                    }
    
    
    
            }
    
        }
    }

## **3，线程间状态的改变：** ##

**线程间的状态改变结构如下**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70][]

**消费者，与生产者进程交互调用wait方法和notify方法的案例：（包子铺卖包子）**

public class CommuteTest {
        private static int i=1;
        public static void main(String[] args) {
    
           Object o=new Object();
            new Thread(){
                @Override
                public void run(){
                    while (true){
                        synchronized (o){
                            System.out.println("告诉老板包子的种类和数量,等待5秒");
                            try {
                                o.wait();//等待老板做包子
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println("顾客"+i+"得到包子，开始吃包子");
                            System.out.println("顾客"+i+"吃完包子跑了了===========================================");
                            i++;
                        }
                    }
    
    
                }
            }.start();
            new Thread(){
                @Override
                public void run(){
                    while (true){
                        try {
                            Thread.sleep(5000);//花费5秒做包子
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (o){
                            System.out.println("老板做好包子了");
                            o.notify();
                        }
                    }
    
                }
            }.start();
    
    
        }
    }

## 4，线程池？ ##

*  什么是线程池：它是一个存储线程的集合，其中的线程可以借出来使用，使用结束后归还到池子。
 *  线程池的优点：线程池中的线程可以被反复使用，减少了资源的消耗，提高了响应速度
 *  JDK1.5之后有内置线程池。
 *  线程池的使用：

线程池:JDK1.5之后提供的

*  Executors类 :线程池的工厂类,用来生成线程池
 *  Executors类中的静态方法:
 *  newFxedThreadPool(int nThreods) 创建一个可重用固定线程数的线程池，传入参数是线程个数，返回的是值是ExecutorService接口的实现类对象
 *  ExecutorService:线程池接口：用来从线程池中获取线程,调用start方法,执行线程任务，submit(Runnable task) 提交一个Runnable任务用于执行

线程池的使用步骤:

1.  使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.  创建一个类, 实现Runnable接口,重写run方法，设置线程任务
3.  调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.  调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
5.  具体实现：

public class Dog implements Runnable {
        String name;
        public Dog(){}
        public Dog(String name){
            this.name=name;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"执行了线程");
    
        }
    }

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class PoolTest {
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(2);
            Dog dog1=new Dog("金毛");
            Dog dog2=new Dog("泰迪");
            executorService.submit(dog1);
            executorService.submit(dog2);
            executorService.submit(new Dog());
            executorService.submit(new Dog());
            executorService.submit(new Dog());
    
        }
    }

[https_blog.csdn.net_weixin_44841312_article_details_104966035]: https://blog.csdn.net/weixin_44841312/article/details/104966035
[https_blog.csdn.net_weixin_44841312_article_details_105191973]: https://blog.csdn.net/weixin_44841312/article/details/105191973
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70]: /images/20221023/593cbde2cd4d42b986f80831c8a5fc7e.png