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());
    }
}

 

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());
    }
}

　　　　注意：

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

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

 

常用API 

• • 　　　　　　　　void　　start()　　　　　　使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
  • 　　　　static Thread currentThread()　　返回对当前正在执行的线程对象的引用
  • 　　　　     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
         */

    }
}

 

线程安全

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

　　即：使用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--;
            }
        }
    }
}

 

　　方式三：使用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();//无论是否异常,都会释放掉锁对象
            }
        }
        
    }
}

 

多线程线程图

　　线程的五种状态：

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

                    　　　　阻塞状态

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

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

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

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

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

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

                          sleep 是Thread 的一个函数

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

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

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

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