java中的多线程 // 基础

java 中的多线程

简介

　　进程 ： 指正在运行的程序，并具有一定的独立能力，即 当硬盘中的程序进入到内存中运行时，就变成了一个进程

　　线程 ： 是进程中的一个执行单元，负责当前程序的执行。线程就是CPU通向程序的路径

　　　　　  一个进程中只有一个线程，单线程程序

　　　　　  一个进程中是可以有多个线程的，这个应用程序是多线程程序

程序的运行分类

　　分时调度

　　　　所有线程轮流使用CPU 的使用权，平均分配每个线程占用CPU 的时间

　　抢占式调度

　　　　优先让优先级高的线程使用CPU，如果线程的优先级相同，那么就会随机选择一个线程（线程的随机性）。

　　　　java 使用的为抢占式调度

　　　抢占式调度简介：

　　　　现在的操作系统都支持多进程并发运行，比如：一边用office ，一边使用QQ，一边看着视频  等等，

　　　　看着好像这些程序都在同一时刻运行，实际上是 CPU（中央处理器）使用抢占式调度模式在多个线程间进行着高速的切换。

　　　　对于CPU的一个核而言，某个时刻只能执行一个线程，而CPU 在多个线程之间切换的速度相对我们而言感觉要快，看上去就是在同一时刻运行。

　　　　注意：

　　　　　　多线程并不能提高程序的运行速度，但能够提高程序的运行效率，让CPU 的使用效率更高。

多线程的由来　　

　　jvm启动后，必然有一个执行线程(路径)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程（main线程）。　

　　若主线程遇到循环，并循环次数较多，则导致程序在指定的位置停留时间过长，无法马上执行下面的程序，则需要等待循环结束后才能够执行代码。效率慢。　

　　主线程负责执行其中的一个循环，由另一个线程执行另一个循环，最终实现多部分代码同时执行。多线程之间互不影响。

多线程的创建方式

　　1、继承 Thread 类

　　　　创建一个类，继承 Thread 类，并重写Thread 类的 run 方法

　　　　创建对象，调用 run 方法 ，就相当于执行其他线程的 main 方法。

　　　　步骤：

　　　　　　1、自定义一个类，继承Thread 类

　　　　　　2、重写Thread 类中的 run 方法 ，设置线程任务

　　　　　　3、创建自定义类的实例

　　　　　　4、实例化 Thread 类，并传入自定义的类

　　　　　　4、调用start ，开启进程。

　　　　示例：

 1、自定义类
 // 创建一个类，继承Thread
 public class Thread_01 extends Thread{
     // 重写run 方法，在run方法中定义线程任务
     public void run(){
         System.out.println(Thread.currentThread().getName());
     }
 }
 2、main方法
 public class ThreadDemo {
     public static void main(String[] args) {
         // 创建线程对象 t1
         Thread_01 t1 = new Thread_01();
         // 为了启动Thread_01 这个线程，需要实例化Thread，并传入自己的Thread_01实例
         Thread thread = new Thread(t1);
         // 通知CPU 要启动线程
         thread.start();
         System.out.println(Thread.currentThread().getName());
     }
 }

多线程继承Thread 示例

2、实现 Runnable 接口

　　　　创建一个类，实现 Runnable 接口，重写 run  方法

　　　　步骤：

　　　　　　1、自定义一个类，实现 Runnable 接口

　　　　　　2、重写run 方法，在run方法中设置线程任务

　　　　　　3、在main 方法中，创建自定义类的实例化

　　　　　　4、实例化Thread 类，并传入自定义类的实例化

　　　　　　5、调用start 方法，开启进程

 1、自定义类，实现runnable 接口
 // 自定义类，实现Runnable 接口
 public class Runnable_01 implements Runnable{
     // 重写run 方法，在run方法中设置线程任务
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName());
     }

 }

 2、在main方法中，调用
 public class ThreadDemo {
     public static void main(String[] args) {
         // 创建线程对象 t1
         Runnable_01 t1 = new Runnable_01();
         // 为了启动Runnable_01 这个线程，需要实例化Thread，并传入自己的Runnable_01实例
         Thread thread = new Thread(t1);
         // 通知CPU 要启动线程
         thread.start();
         System.out.println(Thread.currentThread().getName());
     }
 }

多线程实现 Runnable 接口

　　　　注意：

　　　　　　调用 start 方法，开启新线程。若没有调用start 方法，只调用run 方法，只是调用了一个方法而已，并没有开启新线程

　　　　　　一个线程只能调用一次start 方法，若线程执行结束后，不能再调用。

常用API

• • 　　　　　　　　void　　start()　　　　　　使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
  • 　　　　static ThreadcurrentThread()　　返回对当前正在执行的线程对象的引用
  • 　　　　string　getName()　　　　　返回该线程的名称
  • 　　　　　　　　long　　getId()　　　　　　返回该线程的标识符
  • 　　　　　　　　int　　getPriority()　　　返回线程的优先级
  • 　　　　Thread.State　　getState()　　　　 返回该线程的状态
  • 　　　　　　　　void　　interrupt()　　　　中断线程
  • 　　　　　　　　void　　setName(String name)　　　　改变线程名称，使之与参数 name 相同
  • 　　　　　　　　void　　setPriority(int newPriority)更改线程的优先级
  • 　　　　static　void　　sleep(long millis)　　　　　在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
  • 　　　　static　void　　yield()　　　　　　　　　　　暂停当前正在执行的线程对象，并执行其他线程

 public class Demo {
     public static void main(String[] args) {
         // 调用currentThread().getName()，获取当前线程的名称
         System.out.println(Thread.currentThread().getName() + "123");
         // 调用currentThread().getId()，获取当前线程的标识符
         System.out.println(Thread.currentThread().getId());
         // 调用currentThread().getPriority()，获取当前线程的优先级
         System.out.println(Thread.currentThread().getPriority());
         // 调用currentThread().setName() 给当前线程设置新名称
         Thread.currentThread().setName("线程新名称");
         // 调用currentThread().getName()，获取当前线程的名称
         System.out.println(Thread.currentThread().getName() + "123");
         /**
          * 打印结果 ：main123
          *         1
          *         5
          *         线程新名称123
          */

     }
 }

线程API 使用示例

线程安全

　　若多线程调用全局变量时，会出现线程安全问题。

　　即：使用java 模拟窗口卖票时，一个窗口就是一个线程，若同时卖票，可能会出现几个窗口同时卖一张票，或者卖出不存在的票（就剩一张票时，两个窗口同时卖出）

　　所以，使用多线程时，要注意线程安全问题，解决线程安全问题有三种方式，

　　方式一：同步代码块

　　　　同步代码块：就是在方法块声明上加上 synchronized

synchronized (锁对象) {
	可能会产生线程安全问题的代码
}

　　注意：　

　　　　同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

　　　　对象可以是this, 哪个对象调用，方法中的this就是哪个对象

　　示例：

 /*
  * 开启3个线程,同时卖100张票
  */
 public class Demo01PayTicket {
     public static void main(String[] args) {
         //创建接口的实现类对象
         RunnableImpl r = new RunnableImpl();
         //创建线程对象
         Thread t0 = new Thread(r);
         Thread t1 = new Thread(r);
         Thread t2 = new Thread(r);
         //开启多线程
         t0.start();
         t1.start();
         t2.start();
     }
 }

 /*
  * 发现程序出现了安全问题:卖出了重复的票和不存在的票
  *
  * 多线程安全问题的第一种解决方案:使用同步代码块
  *
  * 注意:
  *         代码块中传递的锁对象必须保证唯一,多个线程使用的是同一个锁对象
  *         锁对象可以是任意的对象
  *
  */
 public class RunnableImpl implements Runnable{

     //定义一个共享的票源
     private int ticket = 100;
     //创建一个锁对象
     Object obj = new Object();

     @Override
     public void run() {
         //让卖票重复执行
         while(true){
             //同步代码块
             synchronized (obj) {
                 //判断是否还有票
                 if(ticket>0){

                     //提高安全问题出现的概率,增加一个sleep
                     try {
                         Thread.sleep(10);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }

                     //进行卖票
                     System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                     ticket--;
                 }
             }
         }
     }
 }

多线程 同步代码块

　　方式二：同步方法

　　　　1、同步方法：在方法声明上加上 synchronized

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

　　同步方法中的锁对象是 this,哪个对象调用，方法中的this就是哪个对象

　　　　2、静态同步方法：在方法声明上加上 static synchronized

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

　　静态同步方法中的锁对象不是对象，是本类的 .class 文件

　　示例：

 /*
  * 开启3个线程,同时卖100张票
  */
 public class Demo01PayTicket {
     public static void main(String[] args) {
         //创建接口的实现类对象
         RunnableImpl r = new RunnableImpl();
         //创建线程对象
         Thread t0 = new Thread(r);
         Thread t1 = new Thread(r);
         Thread t2 = new Thread(r);
         //开启多线程
         t0.start();
         t1.start();
         t2.start();
     }
 }

 /*
  * 发现程序出现了安全问题:卖出了重复的票和不存在的票
  *
  * 多线程安全问题的第二种解决方案:使用同步方法
  *
  * 实现步骤:
  *         1.把访问了共享数据的代码提取出来放在一个方法中
  *         2.在方法上添加一个synchronized修饰符
  *
  * 格式:
  *     修饰符 synchronized 返回值类型 方法名(参数){
  *         访问了共享数据的代码;
  *     }
  *
  * 把选中的代码提取到方法中快捷键:alt+shift+m
  *
  */
 public class RunnableImpl implements Runnable{

     //定义一个共享的票源
     private static int ticket = 100;

     @Override
     public void run() {
         //让卖票重复执行
         while(true){
             payTicketStatic();
         }

     }

     /*
      * 静态的同步方法,锁对象不是this
      * 静态优先于非静态加载到内存中,this是创建对象之后才有的
      * 锁对象是本类的class属性(反射-->class文件对象)
      */
     public static synchronized void payTicketStatic() {
         synchronized (RunnableImpl.class) {
             //判断是否还有票
             if(ticket>0){
                 //提高安全问题出现的概率,增加一个sleep
                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 //进行卖票
                 System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                 ticket--;
             }
         }
     }

     /*
      * 定义一个卖票的方法
      * 使用synchronized修饰
      * 使用锁对象把方法锁住
      * 这个锁对象是谁?
      * 创建的实现类对象new RunnableImpl();
      * 也就是this,哪个对象调用的方法,方法中的this就是哪个对象
      */
     public synchronized void payTicket() {
         //System.out.println(this);//cn.itcast.demo08.RunnableImpl@bcda2d
         synchronized (this) {
             //判断是否还有票
             if(ticket>0){
                 //提高安全问题出现的概率,增加一个sleep
                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }

                 //进行卖票
                 System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                 ticket--;
             }
         }
     }
 }

多线程 同步方法 synchronized

　　方式三：使用lock 锁

　　　　Lock 是接口，　　ReentrantLock 是Lock 的实现类

　　　　API

　　　　　　

　　　　调用

　　　　　　1、创建ReentrantLock 对象

　　　　　　2、在可能产生安全问题代码前调用 lock（） 方法，获得锁

　　　　　　3、调用unlock（）方法，解锁

　　　　

　　ReentrantLock rl = new ReentrantLock();
　　//获得锁
　　rl.LOCK
　　可能会产生线程安全问题的代码
　　Rl.unlock

　　示例：

 /*
  * 开启3个线程,同时卖100张票
  */
 public class Demo01PayTicket {
     public static void main(String[] args) {
         //创建接口的实现类对象
         RunnableImpl r = new RunnableImpl();
         //创建线程对象
         Thread t0 = new Thread(r);
         Thread t1 = new Thread(r);
         Thread t2 = new Thread(r);
         //开启多线程
         t0.start();
         t1.start();
         t2.start();
     }
 }

 /*
  * 发现程序出现了安全问题:卖出了重复的票和不存在的票
  *
  * 多线程安全问题的第三种解决方案:使用Lock锁
  * java.util.concurrent.locks.Lock接口
  * Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
  * JDK1.5之后出现的新特性
  *
  * 实现步骤:
  *     1.在成员位置创建一个ReentrantLock对象
  *     2.在访问了共享数据的代码前,调用lock方法,获取锁对象
  *     3.在访问了共享数据的代码后,调用unlock方法,释放锁对象
  *
  */
 public class RunnableImpl implements Runnable{

     //定义一个共享的票源
     private int ticket = 100;
     //1.在成员位置创建一个ReentrantLock对象
     Lock l = new ReentrantLock();

     @Override
     public void run() {
         //让卖票重复执行
         while(true){
             //2.在访问了共享数据的代码前,调用lock方法,获取锁对象
             l.lock();
             try {
                 //可能会出现安全问题的代码
                 //判断是否还有票
                 if(ticket>0){
                     //提高安全问题出现的概率,增加一个sleep
                     Thread.sleep(10);
                     //进行卖票
                     System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                     ticket--;
                 }

             } catch (Exception e) {
                 //异常的处理逻辑
                 System.out.println(e);
             } finally {
                 //一定会执行的代码,资源释放
                 //3.在访问了共享数据的代码后,调用unlock方法,释放锁对象
                 l.unlock();//无论是否异常,都会释放掉锁对象
             }
         }

     }
 }

多线程 lock 锁 示例

多线程线程图

　　线程的五种状态：

　　　　新建状态-->运行状态-->死亡（结束）状态

　　　　阻塞状态

　　　　　　　　　　冻结状态（休眠/无限等待）

　　　　新建 ：刚创建出来的线程，即 new Thread();

　　　　阻塞 ：没有抢到CPU，在等待CPU调用

　　　　运行 ：调用run 方法，在运行状态

　　　　死亡 ：方法结束，调用完成

　　　　休眠 ：调用sleep() 方法，进入休眠状态

sleep 是Thread 的一个函数

sleep 指占用CPU 不工作，其他线程无法进入。即：sleep不会让出系统资源；

　　　　无限等待 ： 调用wait() 方法，未被唤醒

wait 是object 的一个函数，需要调用notify() 来唤醒

wait 指不占用CPU 不工作，其他线程可以进入。即：wait是进入线程等待池中等待，让出系统资源。