【JAVA多线程学习笔记】（1）实现线程的方式线程生命周期操作线程的方法

小鱼儿 2022-10-14 00:41 165阅读 0赞

### 文章目录 ###

*   *  两种方式实现线程
     *   *  继承Thread类
         *  模拟银行叫号的程序
         *  Runnable接口
         *  代码1：（与swing相结合创建gui程序）
     *  Thread类的⼏个常⽤⽅法
     *  线程生命周期
     *  操作线程的方法
     *   *  代码示例：

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

## 两种方式实现线程 ##

在Java中主要提供两种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口。

1.继承 Thread 类，并重写 run ⽅法；  
2.实现 Runnable 接⼝的 run ⽅法；  
说创建线程有两种方式，一种是创建一个Thread，一种是实现Runnable接口，这种说法是不严谨的。准确地讲，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元则有两种方式，第一种是重写Thread的run方法，第二种是实现Runnable接口的run方法，**并且将Runnable实例用作构造Thread的参数**。  
重写Thread类的run方法和实现Runnable接口的run方法还有一个很重要的不同，**那就是Thread类的run方法是不能共享的**，也就是说A线程不能把B线程的run方法当作自己的执行单元，而使用Runnable接口则很容易就能实现这一点，使用同一个Runnable的实例构造不同的Thread实例。

### 继承Thread类 ###

Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例。Thread类中常用的两个构造方法如下：  
　public Thread()：创建一个新的线程对象。  
　public Thread(String threadName)：创建一个名称为threadName的线程对象。  
　继承Thread类创建一个新的线程的语法如下： 完成线程真正功能的代码放在类的run()方法中，**当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法**。  
　Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run()方法中。run()方法必须使用以下语法格式：

> public void run()\{\}

如果start()方法调用一个已经启动的线程，系统将抛出IllegalThreadStateException异常。

启动一个新的线程，不是直接调用Thread子类对象的run()方法，而是调用Thread子类的start()方法，**Thread类的start()方法产生一个新的线程，该线程运行Thread子类的run()方法**。

public class Demo { 
    public static class MyThread extends Thread { 
    @Override
    public void run() { 
    System.out.println("MyThread");
    }
    }
    public static void main(String[] args) { 
    Thread myThread = new MyThread();
    myThread.start();
    }
    }

调⽤ start() ⽅法后，该线程才算启动！

来看一下Thread start方法的源码，如下所示：

public synchronized void start() { 
     if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
    
        boolean started = false;
        try { 
            start0();
            started = true;
        } finally { 
            try { 
                if (!started) { 
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) { 
            }
        }
    }

也就是说在start方法中会调用start0方法，那么重写的那个run方法何时被调用了呢？单从上面是看不出来任何端倪的，但是打开JDK的官方文档，在start方法中有如下的注释说  
※ Causes this thread to begin execution; the Java Virtual Machine calls the `run` method of this thread.  
上面这句话的意思是：在开始执行这个线程时，JVM将会调用该线程的run方法，换言之，run方法是被JNI方法start0（）调用的，仔细阅读start的源码将会总结出如下几个知识要点。 Thread被构造后的NEW状态，事实上threadStatus这个内部属性为0。 不能两次启动Thread，否则就会出现IllegalThreadStateException异常。 线程启动后将会被加入到一个ThreadGroup中，后文中我们将详细介绍ThreadGroup。 一个线程生命周期结束，也就是到了TERMINATED状态，再次调用start方法是不允许的，也就是说TERMINATED状态是没有办法回到RUNNABLE/RUNNING状态的。

### 模拟银行叫号的程序 ###

假设大厅共有四台出号机，这就意味着有四个线程在工作，下面我们用程序模拟一下叫号的过程，约定当天最多受理50笔业务，也就是说号码最多可以出到50。

package ch1;
    public class TicketWindow extends Thread { 
        //柜台名称
        private final String name;
    
        //最多受理50笔业务
        private static final int MAX = 50;
        private int index = 1;
    
        public TicketWindow(String name) { 
            this.name = name;
        }
    
        @Override
        public void run() { 
            while (index <= MAX) { 
    
                System.out.println("柜台：" + name + "当前的号码是:" + (index++));
            }
        }
        public static void main(String[] args) { 
            TicketWindow ticketWindow1 = new TicketWindow("一号出号机");
            ticketWindow1.start();
    
            TicketWindow ticketWindow2 =new TicketWindow("二号出号机");
            ticketWindow2.start();
    
            TicketWindow ticketWindow3 = new TicketWindow("三号出号机");
            ticketWindow3.start();
    
            TicketWindow ticketWindow4 = new TicketWindow("四号出号机");
            ticketWindow4.start();
    
        }
    
    
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]  
之所以出现这个问题，根本原因是因为每一个线程的逻辑执行单元都不一样，我们新建了四个Ticket Window线程，它们的票号都是从0开始到50结束，四个线程并没有均从客席号服务器进行交互，获取一个唯一的递增的号码，那么应该如何改进呢？无论TicketWindow被实例化多少次，只需要保证index是唯一的即可，我们会立即会想到使用static去修饰index以达到目的，通过对index进行static修饰，做到了多线程下共享资源的唯一性，看起来似乎满足了我们的需求（事实上，如果将最大号码调整到500、1000等稍微大一些的数字就会出现线程安全的问题），但是只有一个index共享资源，如果共享资源很多呢？共享资源要经过一些比较复杂的计算呢？不可能都使用static修饰，而且static修饰的变量生命周期很长，**所以Java提供了一个接口Runnable专门用于解决该问题，将线程的控制和业务逻辑的运行彻底分离开来**。

如果上面的代码改用runnable实现：

public class TicketWindowRunnable implements Runnable
    { 
        //柜台名称
        private int index = 1;//不做static修饰
    
        private final static int MAX = 50;
    
        @Override
        public void run() { 
    
            while (index <= MAX) { 
                System.out.println(Thread.currentThread() + " 的号码是:" + (index++));
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    
    
        public static void main(String[] args) { 
    
            final TicketWindowRunnable task = new TicketWindowRunnable();
    
            Thread windowThread1 = new Thread(task, "一号窗口");
    
            Thread windowThread2 = new Thread(task, "二号窗口");
    
            Thread windowThread3 = new Thread(task, "三号窗口");
    
            Thread windowThread4 = new Thread(task, "四号窗口");
    
            windowThread1.start();
            windowThread2.start();
            windowThread3.start();
            windowThread4.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]

四个叫号机线程，使用了同一个Runnable接口，这样它们的资源就是共享的，不会再出现每一个叫号机都从1打印到50这样的情况。

### Runnable接口 ###

到目前为止，线程都是通过扩展Thread类来创建的，如果程序员需要继承其他类（非Thread类）,而且还要使当前类实现多线程，**那么可以通过Runnable接口来实现**。例如，一个扩展JFrame类的GUI程序不可能再继承Thread类，因为Java语言中不支持多继承，这时该类就需要实现Runnable接口使其具有使用线程的功能。

>     public class Thread extends Object implements Runnable

实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联。Thread类中有以下两个构造方法：  
　public Thread(Runnable target)。 　  
　public Thread(Runnable target,String name)。  
这两个构造方法的参数中都存在Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。

使用Runnable接口启动新的线程的步骤如下：  
（1）建立Runnable对象。  
（2）使用参数为Runnable对象的构造方法创建Thread实例。 （3）调用start()方法启动线程。  
通过Runnable接口创建线程时程序员首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象；接下来使用相应的构造方法创建Thread实例；最后使用该实例调用Thread类中的start()方法启动线程。下图表明了实现Runnable接口创建线程的流程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]  
Runnable 是⼀个函数式接⼝，这意味着我们可以使⽤Java 8的函数式编程来简化代码：

public class Demo { 
    public static class MyThread implements Runnable { 
    @Override
    public void run() { 
    System.out.println("MyThread");
    }
    }
    public static void main(String[] args) { 
    new MyThread().start();
    // Java 8 函数式编程，可以省略MyThread类
    new Thread(() -> { 
    System.out.println("Java 8 匿名内部类");
    }).start();
    }
    }

由于Java“单继承，多实现”的特性，Runnable接⼝使⽤起来⽐Thread更灵活。  
Runnable接⼝出现更符合⾯向对象，将线程单独进⾏对象的封装。  
Runnable接⼝出现，降低了线程对象和线程任务的耦合性。  
如果使⽤线程时不需要使⽤Thread类的诸多⽅法，显然使⽤Runnable接⼝更为轻量。  
**所以，我们通常优先使⽤“实现 Runnable 接⼝”这种⽅式来⾃定义线程类**

### 代码1：（与swing相结合创建gui程序） ###

package hzy;
    import java.awt.Container;
    import java.net. URL;
    import javax.swing.*;
    public class SwingAndThread extends JFrame { 
    
    	
    	private JLabel jl =new JLabel();
    	//声明对象JLabel
    	private static Thread t;
    	//声明线程对象
    	private int count= 0;
    	//∥声明计数变量
    	private Container container= getContentPane();
    	//声明容器
    	public SwingAndThread() { 
    	setBounds(300,200,250,100);
    // ∥绝对定位窗体大小与位置
    	container. setLayout(null);
    	//∥使窗体不使用任何布局管理器
    	URL url= SwingAndThread.class.getResource("/demo.gif");//获取图片的url
    	Icon icon= new ImageIcon(url);
    // 实例化一个con
    	jl.setIcon(icon);
    	//将图标放置在标签中
    	jl.setHorizontalAlignment(SwingConstants.LEFT);
    // ∥设置图片在标签的最左方
    	jl.setBounds(10, 10, 200,50);
    	//设置标签的位置与大小
    	jl.setOpaque(true);
    	
    	t=new Thread(new Runnable(){ 
    	//∥定义匿名内部类,该类实现 Runnable接口
    	public void run(){ 
    	//∥重写run(方法
    	while(count<=200){ 
    //∥设置循环条件
    	jl.setBounds(count, 10, 200, 50);
    	//∥将标签的横坐标用变量表示
    	try{ 
    	Thread.sleep(1000);
    	//∥使线程休眠1000毫秒
    	} catch(Exception e){ 
    	e.printStackTrace();}
    	count += 4;
    	//∥使横坐标每次增加4
    	if(count==200){ 
    	//∥当图标到达标签的最右边时,使其回到标
    	//∥签最左边
    	count= 10;}
    	}}}
    	);
    	t.start();
    // ∥启动线程
    	container.add(jl);
    	//将标签添加到容器中
    	setVisible(true);
    	//∥使窗体可见
    	//设置窗体的关闭方式
    	setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    	}
    	public static void main(String[]args){ 
    	new SwingAndThread();
    	//实例化 Swing一个 AndThread对象
    }
    	}

图标向右移动  
![在这里插入图片描述][20210604152846354.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 3]  
demo.gif放在workspace的bin下面

## Thread类的⼏个常⽤⽅法 ##

currentThread()：静态⽅法，返回对当前正在执⾏的线程对象的引⽤；  
start()：开始执⾏线程的⽅法，java虚拟机会调⽤线程内的run()⽅法；  
yield()：yield在英语⾥有放弃的意思，同样，这⾥的yield()指的是当前线程愿意让出对当前处理器的占⽤。这⾥需要注意的是，就算当前线程调⽤了yield()⽅法，程序在调度的时候，也还有可能继续运⾏这个线程的；  
sleep()：静态⽅法，使当前线程睡眠⼀段时间；  
join()：使当前线程等待另⼀个线程执⾏完毕之后再继续执⾏，内部调⽤的是Object类的wait⽅法实现的；

## 线程生命周期 ##

线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态；当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）；当线程得到系统资源后就进入运行状态。 一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒；当线程调用Thread类中的sleep()方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入／输出请求，该线程将进入阻塞状态，在其等待输入／输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 4]  
虽然多线程看起来像同时执行，**但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，所以才会使人产生线程是同时进行的假象**。在Windows操作系统中，系统会为每个线程分配一小段CPU时间片，一旦CPU时间片结束就会将当前线程换为下一个线程，即使该线程没有结束。 根据图所示，可以总结出使线程处于就绪状态有以下几种方法：  
　调用sleep()方法。  
　调用wait()方法。 　  
　等待输入／输出完成。  
当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态。 　  
线程调用notify()方法。 　  
线程调用notifyAll()方法。 　  
线程调用interrupt()方法。 　  
线程的休眠时间结束。 　  
输入／输出结束。

## 操作线程的方法 ##

一种能控制线程行为的方法是调用sleep()方法，sleep()方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。在前面的实例中已经演示过sleep()方法，它通常是在run()方法内的循环中被使用。

try{ 
    Thread.sleep(2000);
    }catch(Interrupted Exception e)
    { 
    e.printStackTrace();
    }

上述代码会使线程在2秒之内不会进入就绪状态。**由于sleep()方法的执行有可能抛出InterruptedException异常，所以将sleep()方法的调用放在try-catch块中**。虽然使用了sleep()方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。

### 代码示例： ###

该类继承了JFrame类，实现在窗体中自动画线段的功能，并且为线段设置颜色，颜色是随机产生的。

import java.util.Random;
    import java.awt.*;
    import java.net.URL;
    import javax.swing.*;
    public class SwingAndThread extends JFrame { 
    
    	
    
    	private Thread t;
    	//声明线程对象
    	private static Color[]color = { Color.BLACK,Color.BLUE,Color.GRAY,Color.YELLOW};//定义颜色数组
    	
    	private static final Random rand = new Random();//创建随即对象
    	private static Color getc() { 
    		return color[rand.nextInt(color.length)];//获取随机颜色值
    		
    	}
    	public SwingAndThread() { 
    		t = new Thread(new Runnable() { 
    			int x = 30;
    			int y = 50;
    			public void run() { 
    				while(true) { 
    					try { 
    						Thread.sleep(100);//线程休眠0.1秒
    					}catch(InterruptedException e) { 
    						e.printStackTrace();
    					}
    					Graphics graphics = getGraphics();//获取组件绘图上下文对象
    					graphics.setColor(getc());//设置绘图颜色
    					graphics.drawLine(x, y, 100, y++);//绘制直线并递增垂直坐标
    					if(y >=80) { 
    						y = 50;
    					}
    					
    				}
    			}
    		});
    		t.start();
    	}
    			
    			public static void main(String[]args) { 
    				init(new SwingAndThread(),100,100);
    				
    			}
    	public static void init(JFrame frame,int width,int height) { //初始化程序界面的方法
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		frame.setSize(width,height);
    		frame.setVisible(true);
    	}
    	
    
    	}

如果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用Thread类中的join()方法来完成。这就好比此时读者正在看电视，突然有人上门收水费，读者必须付完水费后才能继续看电视。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]: /images/20221014/a7b4c04f9a00488b9296d54f36d06fa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]: /images/20221014/bd6cbcfc6fc4448d86dbdc8e7d31ec00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 2]: /images/20221014/a8c71252f75543c49da0305751e17df8.png
[20210604152846354.png]: /images/20221014/6bb2b507a2cf46519cfdf7f232115487.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 3]: /images/20221014/633ec58c7b74461990e48430dd088ed2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 4]: /images/20221014/1b72b884fb364c439b2f06024dfc9d82.png