JAVA Review-应用程序开发-JAVA多线程-多线程实现方式

小鱼儿 2022-05-22 09:53 228阅读 0赞

## 前言 ##

本章节中我们将学习一下JAVA多线程的实现方式。首先在学习JAVA多线程之前我们需要明白几个问题：

*  java 多线程是什么鬼，它和程序、进程之间有什么苟且？  
    
    
     *  程序  
        通常而言我们可以将程序定义为是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
     *  进程  
        是程序的一次执行过程，或是正在运行的一个程序。 进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。
     *  线程  
        是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。
 *  在哪些场景中我们需要用到多线程，多线程有什么优劣势？
    
     *  应用场景  
        
        
         *  程序需要同时执行两个或多个任务。
         *  程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
         *  需要一些后台运行的程序时。
     *  优劣势
        
         *  优势  
            
            
             *  用户体验更友好，能多并发地完成用户派遣的任务。
             *  提升CPU使用率。
         *  劣势
            
             *  线程过多时在线程切换过程中或消耗系统资源。

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

## 实现方法 ##

在JAVA 中多线程实现有两种方法：继承Thread 类(最终也是实现Runnable接口)和实现Runnable 接口。

*  继承Thread类
    
     *  基本实现步骤
        
         *  定义子类继承Thread类。
         *  子类中重写Thread类中的run方法。
         *  创建Thread子类对象，即创建了线程对象。
         *  调用线程对象start方法：启动线程，调用run方法。
     *  例子
        
         *  场景说明  
            开启三个线程来实现三个生产者各自生产100件产品的实现
         *  代码示例
            
                package coreJavaReview.thread;
                
                /** * 实现多线程的两种方式 * 使用继承Thread类的方式实现多线程 * @author Administrator * */
                public class ThreadCreateByEnxtends { 
                
                    public static void main(String[] args) {
                        productor1 p1 = new productor1();
                        productor2 p2 = new productor2();
                        productor3 p3 = new productor3();
                
                        p1.setName("第一个生产者");
                        p2.setName("第二个生产者");
                        p3.setName("第三个生产者");
                
                        p1.start();
                        p2.start();
                        p3.start();
                    }
                }
                
                //第一个生产者在生产
                class productor1 extends Thread{ 
                    int i = 0;
                    public void run(){
                        while(true){
                                if(i<100){
                                    i++;
                                    System.out.println(Thread.currentThread().getName()+"：在生产第"+i+"件产品！");
                                }else{
                                    break;
                                }
                
                        }
                    }
                }
                //第二个生产者在生产
                class productor2 extends Thread{ 
                    int i = 0;
                    public void run(){
                        while(true){
                            if(i<100){
                                i++;
                                System.out.println(Thread.currentThread().getName()+"：在生产第"+i+"件产品！");
                            }else{
                                break;
                            }
                    }
                    }   
                }
                //第三个生产者在生产
                class productor3 extends Thread{ 
                    int i =0;
                
                    public void run() {
                        while (true) {
                            if (i < 100) {
                                i++;
                                System.out.println(Thread.currentThread().getName() + "：在生产第" + i + "件产品！");
                            } else {
                                break;
                            }
                        }
                    }
                }
 *  实现Runnable接口
    
     *  基本步骤
        
         *  定义子类，实现Runnable接口。
         *  子类中重写Runnable接口中的run方法。
         *  通过Thread类含参构造器创建线程对象。
         *  将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
         *  调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
     *  示例说明
        
         *  例子
            
             *  场景说明  
                开启三个线程来实现三个生产者各自生产100件产品的实现
             *  代码示例
                
                    package coreJavaReview.thread;
                    
                    /** * 实现多线程的两种方式 使用 实现Runable接口 * * @author Administrator * */
                    public class ThreadCreateByRunable { 
                    
                        public static void main(String[] args) {
                            Productor4 p4 = new Productor4();
                            Productor5 p5 = new Productor5();
                            Productor6 p6 = new Productor6();
                    
                            Thread t4 = new Thread(p4);
                            //Thread t5 = new Thread(p4);
                            //Thread t6 = new Thread(p4);
                            Thread t5 = new Thread(p5);
                            Thread t6 = new Thread(p6);
                    
                            t4.setName("第一个Tread");
                            t5.setName("第二个Tread");
                            t6.setName("第三个Tread");
                    
                            t4.start();
                            t5.start();
                            t6.start();
                        }
                    
                    }
                    
                    // 第一个生产者在生产
                    class Productor4 implements Runnable { 
                        int i = 0;
                    
                        public void run() {
                            while (true) {
                                if (i < 100) {
                                    i++;
                                    System.out.println(Thread.currentThread().getName() + "：在生产第" + i + "件产品！");
                                } else {
                                    break;
                                }
                    
                            }
                        }
                    }
                    
                    //第二个生产者在生产
                    class Productor5 implements Runnable { 
                        int i = 0;
                    
                        public void run() {
                            while (true) {
                                if (i < 100) {
                                    i++;
                                    System.out.println(Thread.currentThread().getName() + "：在生产第" + i + "件产品！");
                                } else {
                                    break;
                                }
                    
                            }
                        }
                    }
                    
                    //第三个生产者在生产
                    class Productor6 implements Runnable { 
                        int i = 0;
                    
                        public void run() {
                            while (true) {
                                if (i < 100) {
                                    i++;
                                    System.out.println(Thread.currentThread().getName() + "：在生产第" + i + "件产品！");
                                } else {
                                    break;
                                }
                    
                            }
                        }
                    }

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

## 小结 ##

Extends Thread VS Implements Runnable：

*  继承Thread时线程代码存放Thread子类run方法中。
 *  实现Runnable时线程代码存在接口的子类的run方法。
 *  通常而言我们更建议使Implements Runnable的方式来完成多线程的实现  
    
    
     *  避免了单继承的局限性
     *  多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。(这将关系到线程安全问题，后面的章节我们将会学习到)。