JavaSE——多线程

阅读量：3977 次

发布时间：2019-05-24

本文共 8177 字，大约阅读时间需要 27 分钟。

文章目录

一、创建线程的两种方式

1.1 Thread类

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
run()方法称为线程执行体。

创建Thread子类的实例，即创建了线程对象

调用线程对象的start()方法来启动该线程

自定义线程类：

//1.创建一个Thread类的子类public class MyThread extends Thread{
       //在Thread类的族类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）    @Override    public void run(){
           for(int i=0; i<20; i++){
               System.out.println("run:"+i);        }    }}

测试类

public class Demo01Thread {
       public static void main(String[] args) {
           //3.创建Thread类的子类对象实例        MyThread mt = new MyThread();        //4.调用Thread类中的方法start(),开启新的线程,执行run方法        mt.start();        for(int i=0; i<20; i++){
               System.out.println("main线程:"+i);        }    }}

1.2 Runnable接口

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

调用线程对象的start()方法来启动线程。

步骤一：

public class MyRunnable implements Runnable{
    	@Override 	public void run() {
    		for (int i = 0; i < 20; i++) {
    				System.out.println(Thread.currentThread().getName()+" "+i); 		} 	} }

步骤二三：

public class Demo {
    	public static void main(String[] args) {
    		//创建自定义类对象 线程任务对象 		MyRunnable mr = new MyRunnable(); 		//创建线程对象 		Thread t = new Thread(mr, "小强"); 		t.start(); for (int i = 0; i < 20; i++) {
    		System.out.println("旺财 " + i); 		} 	} }

1.3 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。

可以避免java中的单继承的局限性。

增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

二、线程的五种状态

线程状态	发生条件
New(新建)	线程刚被创建，但是并未启动。还没调用start方法
Runnable(可运行)	一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序来调度的。
Running(运行状态)	当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。
Blocked(锁阻塞)	①线程通过调用sleep方法进入睡眠状态；②线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；③线程试图得到一个锁，而该锁正被其他线程持有；④线程在等待某个触发条件；所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
dead(死亡状态)	①run方法正常退出而自然死亡；②一个未捕获的异常终止了run方法而使线程猝死；为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法，如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false。

三、线程安全

3.1 线程安全

什么是线程安全？

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

线程安全在三个方面的体现：

原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；

可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；

有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。

3.2 线程安全实例

下面以一个实例来描述线程安全问题：

假设来模拟电影院的售票窗口，实现多个窗口同时卖票，总票数100张，窗口使用线程对象来模拟，票使用Runnable接口来模拟；

模拟票：

public class Ticket implements Runnable {
       private int ticket = 100;    /** 执行卖票操作 */    @Override     public void run() {
           //每个窗口卖票的操作        // 窗口 永远开启        while (true) {
               if (ticket > 0) {
                   //有票 可以卖，出票操作，使用sleep模拟一下出票时间                try {
                       Thread.sleep(100);                } catch (InterruptedException e) {
                       // TODO Auto‐generated catch block                    e.printStackTrace();                    //                   }                //获取当前线程对象的名字                String name = Thread.currentThread().getName();                System.out.println(name + "正在卖:" + ticket--);            }        }    }}

测试类

public class Demo {
       public static void main(String[] args) {
           //创建线程任务对象        Ticket ticket = new Ticket();        //创建三个窗口对象        Thread t1 = new Thread(ticket, "窗口1");        Thread t2 = new Thread(ticket,"窗口2");        Thread t3 = new Thread(ticket,"窗口3");        //调用start方法，模拟同时卖票        t1.start();        t2.start();        t3.start();    }}

来看运行结果：

程序出现两个问题：

1.相同的票号被卖了几次。

2.不存在的票，比如0或者-1票，是不存在的。

上面这种问题，几个窗口(线程)票数不同步，被称为线程不安全，那下面来说说线程同步。

四、线程同步

根据上面的案例：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

下面介绍三种方式完成同步操作。

4.1 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式:

synchronized(同步锁){
   	需要同步操作的代码}

底层实现原理：synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。Java中每一个对象都可以作为锁，这是synchronized实现同步的基础。锁对象的作用是把同步代码块锁住,只让一个线程在同步代码块中执行。

测试类与上面一样，修改模拟买票部分代码演示：

public class RunnableImpl implements Runnable{
       //定义一个多线程功共享票源    private int ticket = 100;    //创建一个锁对象    Object obj = new Object();    //设置线程任务    @Override    public void run(){
           //使用死循环，让卖票操作重复执行        while(true){
               //同步代码块            synchronized (obj){
                   //先判断票是否存在                if(ticket>0){
                       //提高安全问题出现的概率，让程序睡眠                    try {
                           Thread.sleep(10);                    } catch (InterruptedException e) {
                           e.printStackTrace();                    }                    //票存在，卖票                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");                    ticket--;                }            }        }    }}

4.2 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：

public synchronized void method(){
   	可能会产生线程安全问题的代码}

还是以卖票案例为基础，测试方法部分不变，代码演示：

public class Ticket implements Runnable {
       private int ticket = 100;    /**     * 执行卖票操作     */    @Override    public void run() {
           //每个窗口卖票的操作 //窗口 永远开启        while (true) {
               sellTicket();        }    }    /**     * 锁对象是谁调用这个方法就是谁     * 隐含锁对象就是 this     */    public synchronized void sellTicket() {
           if (ticket > 0) {
               //有票可以卖, 出票操作, 使用sleep模拟一下出票时间            try {
                   Thread.sleep(100);            } catch (InterruptedException e) {
                   // TODO Auto‐generated catch block                e.printStackTrace();            }            //获取当前线程对象的名字            String name = Thread.currentThread().getName();            System.out.println(name+"正在卖"+ticket--);        }    }}

4.3 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。

public void unlock() :释放同步锁。

使用步骤：

1.在成员位置创建一个ReentrantLock对象    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

还是以卖票案例为基础，加上Lock锁，代码演示：

public class RunnableImpl implements Runnable{
       //定义一个多线程功共享票源    private int ticket = 100;    //1.在成员位置创建一个ReentrantLock对象    Lock l = new ReentrantLock();    //设置线程任务    @Override    public void run(){
           //使用死循环，让卖票操作重复执行        while(true){
               //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁            l.lock();            //先判断票是否存在            if(ticket>0){
                   //提高安全问题出现的概率，让程序睡眠                try {
                       Thread.sleep(10);                    //票存在，卖票                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");                    ticket--;                } catch (InterruptedException e) {
                       e.printStackTrace();                }finally {
                       //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁                    l.unlock();//无论程序是否异常,都会把锁释放                }            }        }    }}