线程与同步

一、线程

  1.1多线程原理

  我们先定义一个线程类,代码如下:

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:07
 6  */
 7 public class MyThread extends Thread {
 8     /**
 9      * 利用继承中的特点
10      * 将线程名称传递,进行设置
11      *
12      * @param name 线程的名称
13      */
14     public MyThread(String name) {
15         super(name);
16     }
17 
18     /**
19      * 重写run方法
20      * 定义线程要执行的代码
21      */
22     @Override
23     public void run() {
24         for (int i = 0; i < 20; i++) {
25             // getName()方法来自父亲
26             System.out.println(getName() + i);
27         }
28     }
29 }

  再定义一个测试类,如下:

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:15
 6  */
 7 public class MyThreadTest {
 8     public static void main(String[] args) {
 9         MyThread mt = new MyThread("小强");
10         // 开启新的线程
11         mt.start();
12         for (int i = 0; i < 20; i++) {
13             System.out.println("旺财" + i);
14         }
15     }
16 }

  执行流程图如下:

 

  程序启动时运行main时候,Java虚拟机启动一个进程,主线程main在main()调用的时候被创建,随着调用mt对象的start方法,另外一个新的线程也启动了,这样,这个应用就在多线程下运行。要想让效果看起来更明显一些,我们可以让打印的次数更多一些来执行。

  多线程在执行时,在栈内存中,每一个执行线程都有一片自己所属的栈内存空间,进行方法的压栈和弹栈。

  当执行线程的任务结束了,线程自动在栈内存中释放了,但是当所有的执行线程都结束了,那么进程就结束了。

   1.2 Thread类

  构造方法:

  • public Thread():分配一个新的线程对象
  • public Thread(String name):分配一个指定名字的新的线程对象
  • public Thread(Runable target):分配一个带有指定目标新的线程对象
  • public Thread(Runable target,String name):分配一个带有执行目标新的线程对象并指定名字

   常用方法:

  • public String getName():获取当前线程名称
  • public void start():导致此线程开始执行;Java虚拟机调用此线程的run方法
  • public void run(): 此线程要执行的任务在此处定义代码
  • public static void sleep(Long milllis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)
  • public static Thread currentThread():返回对当前正在执行的线程对象的引用

   我们在查询API后可以得知创建线程的方式总共有两种,一种是继承Thread类方法,一种是时间Runable接口方式,前面的我们展示的是第一种,现在我们讲解第二种

  1.3 创建线程的方式二

  采用Java.lang.Runnable也是非常常见的方法之一,我们只需要重写run方法即可

  步骤如下:

  • 定义Runnable接口的实现类,并且重写该接口的run()方法,该run()方法的方法体同样是该线程的执行体
  • 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象
  • 调用线程对象的start()方法来启动线程

  代码如下:

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:53
 6  */
 7 public class MyRunnable implements Runnable{
 8     @Override
 9     public void run() {
10         for (int i = 0; i < 20; i++) {
11             System.out.println(Thread.currentThread().getName()+i);
12         }
13     }
14 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:55
 6  */
 7 public class MyRunnableTest {
 8     public static void main(String[] args) {
 9         // 创建自定义类对象,线程任务对象
10         MyRunnable mr = new MyRunnable();
11         // 创建线程对象
12         Thread t = new Thread(mr, "小强");
13         t.start();
14         for (int i = 0; i < 20; i++) {
15             System.out.println("旺财" + i);
16         }
17     }
18 }

  通过实现Runnable接口,使得该类有了多线程类的特性。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法中,Thread类实际上也是实现了Runnable接口的类。

  在启动多线程的时候,需要先通过Thread类的构造方法Thread(Runnable targer)构造出对象,然后调用Thread对象的start()方法来运行多线程代码。

  实际上所有的所线程代码都是通过Thread的start()方法来运行的,因此,不管是继承Thread类还是实现Runnable接口来实现多线程,最终还是通过Thread对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。

  tips:Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run方法仅作为线程执行体。而时间的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。

  1.4 Thread和Runable的区别

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

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

  1. 适合锁哥相同的程序代码的线程去共享一个资源
  2. 可以避免Java中出现单继承的局限性
  3. 增加线程的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
  4. 线程池只能放入实现Runnable或者Callable类线程,不能直接放入继承Thread的类

  补充:在Java中,每次程序的运行至少启动两个线程。一个是main线程,一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候,实际上都会启动一个JVM,每一个JVM其实就是在操作系统中启动了一个进程

  1.5 匿名内部类方式实现线程的创建

  使用线程的匿名内部类的方式,可以方便的实现每个线程执行不同的线程操作。

  使用匿名内部类的方式实现Runable接口,重写Runnable接口中的run()方法:

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:15
 6  */
 7 public class NoNameInnerClassThread {
 8     public static void main(String[] args) {
 9         Runnable r = new Runnable() {
10             @Override
11             public void run() {
12                 for (int i = 0; i < 20; i++) {
13                     System.out.println("小强" + i);
14                 }
15             }
16         };
17         new Thread(r).start();
18         for (int i = 0; i < 20; i++) {
19             System.out.println("旺财" + i);
20         }
21     }
22 }

二、线程安全

  2.1 线程安全

  如果有多个线程在同时运行,而这些线程可能会同时运行这段代码。程序每次运行的结构单线程一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。

  我们用一个生活中常见的电影院卖票的案例来演示线程的安全问题:

  我们模拟电影院现在要播放一场电影,《楚门的世界》,本次电影总共是有100个座位,三个窗口同时开启卖票。

  用线程对象来模拟窗口,票的张数来模拟Runnable接口的子类

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9     @Override
10     public void run() {
11         // 每个窗口都可以执行卖票,窗口全部开启
12         while (true){
13             // 有票可以卖
14             if (ticket > 0){
15                 try {
16                     // sleep模拟出票时间
17                     Thread.sleep(100);
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21                 // 获取当前线程对象的名字
22                 String name = Thread.currentThread().getName();
23                 System.out.println(name + "正在卖第" + ticket-- + "张票");
24             }
25         }
26     }
27 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:29
 6  */
 7 public class TicketTest {
 8     public static void main(String[] args) {
 9         // 创建线程任务对象
10         Ticket ticket = new Ticket();
11         // 创建撒个窗口对象
12         Thread thread1 = new Thread(ticket, "窗口1");
13         Thread thread2 = new Thread(ticket, "窗口2");
14         Thread thread3 = new Thread(ticket, "窗口3");
15 
16         //三个窗口同时卖票
17         thread1.start();
18         thread2.start();
19         thread3.start();
20     }
21 }

  这时候就会出现问题:

  后面的票提前卖,票被超卖,以及票被重复卖等等问题。

  这种问题,就是因为几个窗口的票数不同步了,我们称之为线程不安全

  线程安全问题都是由全局变量和静态变量引起的,如果每个线程对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量时线程安全的,但是如果有多个线程同时执行写操作,我们就要考虑线程安全的问题了。

  2.2 线程同步

  Java中对于多线程的问题提供了同步机制(synchronized)来解决这个问题。

  有三种方式可以完成同步操作:

  • 同步代码块
    • synchronized关键字可以用于方法中的某个区域中,表示对这个区块的资源实行互斥访问,格式如下:
    • 1 synchronized(同步锁){
      2      需要同步操作的代码  
      3 }
    • 同步锁:对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁
      • 锁对象可以是任意类型
      • 多个线程对象要使用同一把锁
      • 注意:在任何时候,最多允许一个线程拥有同步锁进入代码块,其他的线程只能在外面等着
      •  1 package com.buwei;
         2 
         3 /**
         4  * @author buwei
         5  * @date 2018/12/24 21:24
         6  */
         7 public class Ticket implements Runnable {
         8     private int ticket = 100;
         9 
        10     @Override
        11     public void run() {
        12         // 每个窗口都可以执行卖票,窗口全部开启
        13         synchronized (this){
        14             while (true){
        15                 // 有票可以卖
        16                 if (ticket > 0){
        17                     try {
        18                         // sleep模拟出票时间
        19                         Thread.sleep(100);
        20                     } catch (InterruptedException e) {
        21                         e.printStackTrace();
        22                     }
        23                     // 获取当前线程对象的名字
        24                     String name = Thread.currentThread().getName();
        25                     System.out.println(name + "正在卖第" + ticket-- + "张票");
        26                 }
        27             }
        28        }
        29     }
        30 }
  • 同步方法
    • 使用synchronized修饰的方法,就叫做同步方法,保证线程A执行该方法的时候其他线程只能在方法外等着,格式如下:
    • 1 public synchronized void method(){
      2     可能会产生线程安全问题的代码  
      3 }
    • 对于非static方法,同步锁就是this
    • 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)
    • 使用同步方法代码如下:
    •  1 package com.buwei;
       2 
       3 /**
       4  * @author buwei
       5  * @date 2018/12/24 21:24
       6  */
       7 public class Ticket implements Runnable {
       8     private int ticket = 100;
       9 
      10     @Override
      11     public void run() {
      12         // 每个窗口都可以执行卖票,窗口全部开启
      13         while (true) {
      14             sellTicket();
      15         }
      16     }
      17 
      18     public synchronized void sellTicket(){
      19         // 有票可以卖
      20         if (ticket > 0){
      21             try {
      22                 // sleep模拟出票时间
      23                 Thread.sleep(100);
      24             } catch (InterruptedException e) {
      25                 e.printStackTrace();
      26             }
      27             // 获取当前线程对象的名字
      28             String name = Thread.currentThread().getName();
      29             System.out.println(name + "正在卖第" + ticket-- + "张票");
      30         }
      31     }
      32 }
  •  Lock锁:java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象

  • public void lock():加同步锁
  • public void unlock():释放同步锁
  • public void trylock():如果获取锁的时候锁被占用就返回false,否则返回true
  • 使用如下:
  •  1 package com.buwei;
     2 
     3 import java.util.concurrent.locks.Lock;
     4 import java.util.concurrent.locks.ReentrantLock;
     5 
     6 /**
     7  * @author buwei
     8  * @date 2018/12/24 21:24
     9  */
    10 public class Ticket implements Runnable {
    11     private int ticket = 100;
    12 
    13     Lock lock = new ReentrantLock();
    14 
    15     @Override
    16     public void run() {
    17         // 每个窗口都可以执行卖票,窗口全部开启
    18         while (true) {
    19             lock.lock();
    20             // 有票可以卖
    21             if (ticket > 0) {
    22                 try {
    23                     // sleep模拟出票时间
    24                     Thread.sleep(100);
    25                 } catch (InterruptedException e) {
    26                     e.printStackTrace();
    27                 }
    28                 // 获取当前线程对象的名字
    29                 String name = Thread.currentThread().getName();
    30                 System.out.println(name + "正在卖第" + ticket-- + "张票");
    31             }
    32             lock.unlock();
    33         }
    34     }
    35 }

 三、线程状态

   3.1 线程状态概述

   当线程被创建并启动以后,它即不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,在线程的生命周期中,在Java.lang.Thread.State枚举类中给了六种线程状态:

  3.2 Timed Waiting(计时等待)

  描述:一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。

  在我们在的run方法方法中添加sleep语句就是所谓的TimedWaiting计时等待

  • 进入Timed_Waiting状态的一种常见情形是调用的sleep方法,单独的线程也可以调用,不一定非要有协作关系
  • 为了让其他线程有机会执行,可以将Thread.sleep()的调用放在线程run()之内,这样才能保证该线程执行过程中睡眠
  • sleep与锁无关,线程睡眠到期自动苏醒,并返回到Runnable(可运行)状态

   sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始like执行

   Timed Waiting线程状态图

  3.3 Blocked(锁阻塞)

   描述:一个正在阻塞等待一个监视器锁(锁对象)的线程处于这一状态。

  比如:线程A与线程B代码中使用同一锁,如果线程A获取到锁,线程A进入到Runnable状态,name线程B就进入到Blocked锁阻塞状态。

  这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态,Blocked线程状态图如下:

  3.4 Waiting(无线等待)

   描述:一个正在无限期等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。

  Waiting线程状态图:

  

  3.5 补充知识点

  tips:我们在翻阅API的时候会发现Timed Waiting(计时等待) 与 Waiting(无限等待) 状态联系还是很紧密的,比如Waiting(无限等待) 状态中wait方法是空参的,而timed waiting(计时等待) 中wait方法是带参的。这种带参的方法,其实是一种倒计时操作,相当于我们生活中的小闹钟,我们设定好时间,到时通知,可是如果提前得到(唤醒)通知,那么设定好时间在通知也就显得多此一举了,那么这种设计方案其实是一举两得。如果没有得到(唤醒)通知,那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来;如果在倒计时期间得到(唤醒)通知,那么线程从Timed Waiting状态立刻唤醒。

四、Lock锁和synchronized的区别

  下表来自:https://blog.csdn.net/u012403290/article/details/64910926

posted @ 2018-12-24 22:28  Java梦工厂  阅读(208)  评论(0编辑  收藏  举报