Java中多线程、一

线程是程序中执行的线程，Java虚拟机允许应用程序同时运行多个执行线程。

一、线程创建方式

*
* 程序、进程、线程：
*   程序（program）：为了完成特定任务，用某种语言编写的一组指令的集合。指一段静态的代码，静态对象
*   进程（process）：是程序的一次执行过程，或是一个正在运行的程序。是一个动态的过程
*       有其产生、存在和消亡的过程（生命周期）
*       系统会在运行时为每个进程分配不同的内存区域
*   线程（thread）：进程可进一步细分为线程，是程序内部的一条执行路径
*       若一个进程同一时间 并行 执行多个线程，就是支持多线程
*       线程作为调度和执行的单位，每个线程拥有独立的 运行栈和程序计数器，线程切换开销小
*       一个进程中的多个线程共享相同的内存单元/内存地址空间，他们从同一个堆中分配对象，
*           可以访问相同的变量和对象。这使得线程件通信更简便、高效。
*           但多个线程操作共享的系统资源可能带来安全隐患
*
* 单核CPU和多核CPU：
*   单核CPU：是一种假的多线程，在一个时间单元内，只能执行 一个线程 的任务
*       但因为CPU时间单元很短，线程切换是就察觉不出来
*   多核CPU：可更好发挥多线程的效率。现有的服务器大多都是多核的
*   一个Java应用程序java.exe，其实至少有三个线程：main()主线程、gc()垃圾回收线程、异常处理线程
*       如果发生异常，会影响主线程
*
* 并行与并发：
*   并行：多个CPU（处理器）同时执行多个任务。具有同时处理多个任务的能力（同一时刻发生）
*   并发：一个CPU或多个CPU（采用时间片）同时执行多个任务。比如：（秒杀）
*       具有处理多个任务的能力，不一定要同时（相当于CPU同时处理不完任务，微观交替执行）
*       并发性是对有限物理资源强制行使多用户共享以提高效率
*   并发是指一个处理器同时（宏观上同时，微观上有时间片的切换）处理多个任务，假装同时执行多个操作
*       同一时刻只能有一条指令执行，多个进程指令被快速的轮换执行，在宏观上使出现多个进程同时执行的效果
*   并行是指多个处理器同时（微观宏观都是同时）处理多个不同的任务
*   并发是逻辑上的同时发生，并行是物理上的同时发生
*
* 使用多线程优点：
*   在单核CPU中，只使用单个线程先后完成多个任务（调用多个方法），这比用多个线程
*       来完成用的时间短，为何还要使用多线程？
*   采用多线程不会提高程序的执行速度，反而会降低速度，但对于用户来说，可以减少响应时间
*   优点：
*       1 提高应用程序的响应，对图形化界面更有意义，可增强用户体验
*       2 提高计算机系统CPU的利用率
*       3 将长且复杂的进程分为多个线程，独立运行，利于理解和修改
*
* 何时需要多线程？
*   1 程序需要执行两个或多个任务
*   2 程序需要实现一些需要等待的任务。如用户输入、文件读写操作、网络操作、搜索等
*   3 需要一些后台运行的程序
*
* 线程的创建和使用
*   Java中JVM允许程序运行多个线程，通过java.lang.Thread类来实现
*   Thread类特性：1 每个线程都是通过某个特定的Thread对象的run()方法来完成操作
*                   通常把run()方法的主体称为线程体
*               2 启动线程只有一种方式
*                 即通过该Thread对象的start()方法来启动这个线程，不是直接调用run()
*   创建方式一：Thread类
*       构造器：Thread(): 创建新的Thread对象
*           Thread(String threadname): 创建线程并指定线程实例名
*           Thread(Runnable target): 指定创建线程的目标对象，它实现了Runnable接口中的run()方法
*           Thread(Runnable target, String name): 创建新的Thread对象
*       创建过程：
*           继承Thread类
*               1 定义子类继承Thread类 2 子类中重写Thread类中的run()方法
*               3 创建Thread子类对象，即创建了线程对象 4 调用线程对象的start方法：启动线程，调用run方法
*   创建方式二：
*       实现Runnable接口并覆写run()方法。尽量使用实现方式
*
*   继承方式和实现方式的区别于联系
*       区别：继承Thread，线程代码存放于Thread子类的run方法中
*           实现Runnable，线程代码存放于接口子类的run方法中
*       实现方式的好处：
*           避免单继承的局限性
*           多个线程可以共享同一个接口实现类对象，适合多个线程处理同一份资源
* */

public class _01_Create {

    public static void main(String[] args) {
        // 方式1创建线程对象（多态）
        Thread processor1 = new Processor1();
        // 启动线程，会自动执行run()方法，不能手动调用run()ff
        processor1.start();

        // 方式2创建线程对象
        Thread processor2 = new Thread(new Processor2());
        processor2.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("main线程："+i);
        }
    }
}

// 继承Thread类
class Processor1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("测试线程创建方式1："+i);
        }
    }
}

// 实现Runnable接口
class Processor2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("测试线程创建方式2："+i);
        }
    }
}

二、线程优先级

*
* 线程优先级
*   Java的调度方法
*       同优先级线程组成先进先出队列（先到先服务），使用时间片策略
*       对高优先级，使用优先调度的抢占式策略
*   优先级：Java中分为10个等级，分别是1~10
*   在Thread类中提供了三个常量，分别保存1,5,10优先级
*       最高 10 ：Thread.MAX_PRIORITY
*       正常 5 ：Thread.NORM_PRIORITY
*       最低 1 ：Thread.MIN_PRIORITY
*   线程创建时继承父线程的优先级
*   低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调度
*
* 常用方法
*   start(): 启动线程唯一方式
*   getName(): 获取线程名字
*   setName(): 设置线程名字，默认是Thread-0，Thread-1 ...
*   getPriority()：获取该线程优先级
*   setPriority()：设置该线程优先级
*   static currentThread()：获取当前线程的内存地址（获取当前进程对象）
*       写在哪个线程中，就获取哪个线程的对象
*   static sleep(): 让当前线程进入睡眠，参数是毫秒数
*       写在哪个线程，就是哪个线程睡眠
* */

public class _02_Priority {

    public static void main(String[] args) {
        Thread thread = new Processor_01();
        // 设置thread线程对象的 优先级为最大（10）
        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();

        // currentThread()：静态方法，获取当前进程对象
        // 设置main方法（主线程）优先级为1
        Thread.currentThread().setPriority(1);
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程（主线程）："+i);
        }
    }
}

class Processor_01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("测试线程："+i);

        }
    }
}

三、线程生命周期

*
* 生命周期
*   创建->就绪->运行->阻塞->复活->阻塞....->死亡
*   JDK中用Thread.State类定义线程的几种状态
*   要想实现多线程，必须在主线程中创建新的线程对象。线程对象的一个完整生命周期通常要经历以下五种状态
*       新建：当一个Thread类或其子类对象被声明并创建时，新生的线程对象处于新建状态
*       就绪：处于新建状态的线程执行start方法后，将进入线程队列等待CPU时间片，
*           此时具备运行条件，只是还没分配到CPU资源
*       运行：当就绪的线程被调度且获得CPU资源时，就进入了运行状态，run方法定义了线程的操作和功能
*       阻塞：在某种特殊的情况下，被人为挂起或执行输入输出操作时，让出CPU并
*           临时中止了自己的执行，进入阻塞状态
*       死亡：线程完成了它的全部工作 或 线程被提前强制终止 或 出现异常导致结束
* */

public class _03_LifeCycle {

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Processor_02());
        Thread thread2 = new Thread(new Processor_02());
        // thread1 和 thread2 在创建对象时，就已经生成名字Thread-0和Thread-1
        // 此时 把 thread1线程 名字设置为 thread1 ，thread2线程名字依旧是Thread-1
        thread1.setName("thread1");

        // 启动线程，进入就绪状态
        thread1.start();
        thread2.start();

        for (int i = 0; i < 10; i++) {
            // 静态方法，获取当前线程对象
            // 静态方法和对象无关，所以使用类名调用
            System.out.println(Thread.currentThread().getName()+"主线程: "+i);
            try {
                // 睡眠1秒（1000毫秒），进入阻塞
                // sleep方法同样是静态方法，跟对象调用无关，编译后转换成对应的类名
                // 因此不管是thread1还是thread2调用sleep方法都是main线程阻塞
                // 想要阻塞线程对象 thread1 和 thread2 需要在其所属类Processor_02中调用sleep()方法
                Thread.sleep(1000);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

class Processor_02 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            // 获取当前线程对象，并调用getName
            // 由于没有继承Thread类，不能直接使用this调用Thread相对应的方法
            // 因此需要使用Thread类的currentThread()方法获取当前线程对象，
            // 才能使用Thread对应的方法
            System.out.println(Thread.currentThread().getName()+"测试: "+i);
            // 使线程对象thread1睡眠500毫秒
            if (Thread.currentThread().getName().equals("thread1")){
                try {
                    Thread.sleep(500);
                } catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

四、线程控制

*
* 线程控制
*   即通过API控制线程之间的转换
*   常用方法：
*       isAlive(): 判断线程是否还为终止
*       join(): 调用某线程的该方法，将当前线程和该线程“合并”，即等待该线程结束，再恢复当前线程运行
*       yield(): 让出CPU，当前线程进入就绪队列等待调度
*   Object类中的方法
*       wait(): 让当前线程进入对象的wait pool
*       notify()/notifyAll(): 唤醒对象的 wait pool 中的一个/所有等待线程
*
* sleep方法让当前线程睡眠
* 唤醒睡眠的线程有两种方式
*    1 正常唤醒：睡眠时间到了自动唤醒
*    2 异常唤醒：强制打断睡眠，会报异常
* interrupt()：强制唤醒某个线程
* */

public class _04_Interrupt_Join {

    public static void main(String[] args) {
        Thread thread1 = new Processor_03();
        thread1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 1秒后，唤醒thread线程，打断睡眠
        // 强制唤醒，会报异常：java.lang.InterruptedException: sleep interrupted
        thread1.interrupt();

        Thread thread2 = new Thread(new Processor_04());
        thread2.setName("线程2");
        thread2.start();
        try {
            // 合并线程
            // 当前线程（也就是main线程），需要等待“线程2”线程执行完之后，再继续执行
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // main线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Processor_03 extends Thread{
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
            System.out.println("线程睡醒");
        } catch (InterruptedException e){
            e.printStackTrace();
            System.out.println("线程睡眠被打断");
        }
        System.out.println("线程1开始工作");
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
        System.out.println("线程1工作结束");
    }
}

class Processor_04 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

*
* yield(): 让出CPU，当前线程进入就绪队列等待调度
*   暂停当前正在执行的线程，并指向其他线程
*   1 静态方法，写在哪个线程，哪个线程就让位
*   2 给相同的优先级让位，不同优先级不让位
*   3 当前线程正在执行（拿到时间片），把该执行机会（时间片）让给其他线程
* */
public class _05_Yield {

    public static void main(String[] args) {
        Thread thread = new Professor_05();
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
    }
}

class Professor_05 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            // 让位
            Thread.yield();
            // 继承Thread类，可以直接调用getName()方法
            System.out.println(getName()+": "+i);
        }
    }
}

*
* stop: 终止一个线程，容易出现死锁等问题。不太安全，不推荐使用
* 可以用标识符形式来结束
* */
public class _06_Stop {

    public static void main(String[] args) {
        Processor_06 thread = new Processor_06();
        thread.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 3秒后 终止thread线程。容易出现问题
        // thread.stop(); // 方法上给删除线，不推荐使用

        // 推荐使用标识符解决
        thread.isStop = true;
    }
}

class Processor_06 extends Thread{

    boolean isStop = false;

    @Override
    public void run() {
        for (int i = 0; true; i++) {
            // 标识符
            if (isStop){
                return;
            }
            System.out.println(getName()+": "+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、线程同步机制

*
 * 问题？
 *   多个线程执行的不确定性引起执行结果的不稳定
 *   多个线程对内存的共享，会造成操作的不完整性，会破坏数据
 * 线程同步机制
 *   当多个线程操作同一个数据时，为了保证数据的一致
 *   线程同步本质就是数据同步，是一种安全机制
 * 异步编程
 *   线程之间是完全独立的，谁的运行也不会受到别的线程的影响
 * 同步编程
 *   线程之间不是相互独立扥，相互之间有影响，同一时间段某个功能必须只能让一个线程执行，主要是为了数据安全
 * 同步的原因：
 *   1 数据同步，可以理解为暂时把多线程转换为单线程。为了数据安全
 *   2 什么时候需要同步？
 *       1 多线程环境下（单线程没有并发和冲突情况）
 *       2 多个线程有同时操作同一个数据的可能性
 *       3 在针对数据更改操作时
 * 解决方案（存在安全问题）
 *   Java对多线程的安全问题提供解决方法：同步机制
 *   1 同步代码块
 *       synchronized(对象){需要被同步的代码}
 *   2 synchronized还可以放在方法声明中，表示整个方法为同步方法
 *       如：public synchronized void show(String name){...}
 * 在方法上加synchronized（锁）修饰的成员方法，表示该方法不能被多个线程同时访问
 * 锁是每个对象都有的，synchronized只是把锁锁住的持续动作，而多个线程必须保存同一个对象，
 *   才能使用同一把锁，这样才能相互排斥，才能保证数据安全
 * 如果多个线程之间保存的不是同一个对象，尽管是同一个类的不同对象，也无法相互排斥
 * */
*
 * 同步锁机制
 *   对于并发操作，需要用某种方式来防止两个任务访问相同的资源（资源共享竞争）
 *   防止这种冲突的方法，就是当资源被一个任务使用时，在其上加锁。
 *   第一个访问某项资源的任务必须锁定这项资源，使其它任务在其被解锁之前，无法访问这项资源
 *   在其解锁之后，另一个任务就可以锁定并使用它
 *
 * synchronized的锁是什么？
 *   任意对象都可以作为同步锁，所有对象都自动含有单一的锁（监视器）
 *   同步方法的锁：静态方法(类名.class)、非静态方法(this)
 *   同步代码块：自己指定，多数情况指定为this或者类名.class
 *
 * 注意：
 *   必须确保使用同一个资源的多个线程共用一把锁，否则无法保证共享资源的安全
 *   一个线程类中的所有静态方法共用一把锁(类名.class)，所有非静态方法共用一把锁(this)
 *
 * 释放锁的操作
 *   1 当前线程的同步方法、同步代码块执行结束
 *   2 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的执行
 *   3 当前线程在同步代码块、同步方法中出现了未处理的Error和Exception。导致异常结束
 *   4 当前线程在同步代码块、同步方法中执行了线程的wait()方法，当前线程暂停并释放锁
 *
 * 不会释放锁的操作
 *   1 线程执行同步代码块、同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程执行
 *   2 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监听器）
 *       应避免使用suspend()和resume()方法来控制线程
 * */

public class _07_Synchronization {

    public static void main(String[] args) {
        // 创建账户对象，余额为5000
        Account account = new Account(5000);
        // 两个线程对象保存同一个账户对象（操作同一个数据）
        Thread thread1 = new Thread(new Processor_07(account,1000));
        Thread thread2 = new Thread(new Processor_07(account,1000));

        thread1.setName("thread1");
        thread2.setName("thread2");
        thread1.start();
        thread2.start();

        // 执行结果（出现问题），如何解决（线程同步机制）？
        // thread2取款成功，取款: 1000.0元，余额是: 3000.0
        // thread1取款成功，取款: 1000.0元，余额是: 3000.0

        // 方案1 ：同步代码块
//        synchronized (account){
//            thread1.setName("thread1");
//            thread2.setName("thread2");
//            thread1.start();
//            thread2.start();
//        }
    }
}

// 线程类
class Processor_07 implements Runnable{

    // 保存账户对象
    private Account account;
    private double money; // 取款金额

    public Processor_07(Account account,double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        account.withDraw(money);
    }
}

// 实体类，账户
class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    /**
     * 取钱方法
     * @param money money
     */
    public synchronized void withDraw(double money){
        System.out.println(Thread.currentThread().getName() +
                "来取钱了");
        double after = balance - money;
        try {
            // 哪个进程先进来，哪个线程睡眠
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance = after;
        System.out.println(Thread.currentThread().getName() +
                "取款成功，取款: "+money+"元，余额是: "+this.getBalance());

        // 未加synchronized修饰 输出：
        // 因为未加锁，所以该方法可以N个线程同时方法
        // thread1来取钱了
        // thread2来取钱了
        // thread1取款成功，取款: 1000.0元，余额是: 4000.0
        // thread2取款成功，取款: 1000.0元，余额是: 4000.0


        // 加synchronized修饰 输出：
        // thread1来取钱了
        // thread1取款成功，取款: 1000.0元，余额是: 4000.0
        // thread2来取钱了
        // thread2取款成功，取款: 1000.0元，余额是: 3000.0
    }
}

*
* Lock
*   从JDK1.5开始，Java提供了更加强大的线程同步机制，即通过显示定义同步锁对象来实现同步
*       同步锁使用Lock对象充当
*   java.util.concurrent.locks.Lock接口来控制多个线程对共享资源进行访问
*   锁提供了随共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源
*   之前应先获得Lock对象
*   ReentrantLock类实现了Lock，他拥有与synchronized相同的并发性和内存语义
*   在实现线程安全的控制中，常用的是ReentrantLock，可以显式加锁和释放锁
* synchronized与Lock对比:
*   1 Lock是显式锁（手动开启和关闭锁，用完之后应关锁），synchronized是隐式锁，出了作用域自动释放
*   2 Lock只有代码块锁，synchronized有代码块锁和方法锁
*   3使用Lock锁，JVM将花费更少的时间调度线程，性能更好。且具有更好的扩展性（提供更多子类）
* 有限使用锁顺序：
*   Lock、同步代码块（已经进入了方法体，分配了相应资源）、同步方法（在方法体之外）
* */

public class _08_Lock {

    public static void main(String[] args) {
        ATM atm = new ATM(5000);
        Thread thread1 = new Thread(new Processor_08(atm, 1000));
        Thread thread2 = new Thread(new Processor_08(atm, 1000));
        thread1.setName("thread1");
        thread2.setName("thread2");
        thread1.start();
        thread2.start();
    }
}

// 线程类
class Processor_08 implements Runnable{

    // 保存账户对象
    private ATM atm;
    private double money; // 取款金额

    public Processor_08(ATM atm,double money) {
        this.atm = atm;
        this.money = money;
    }

    @Override
    public void run() {
        atm.withDraw(money);
    }
}

class ATM{
    private double balance;

    // 锁
    Lock lock = new ReentrantLock();

    public ATM(double balance) {
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    /**
     * 取钱方法
     * @param money money
     */
    public void withDraw(double money) {
        System.out.println(Thread.currentThread().getName() +
                "来取钱了");
        // ----非访问数据区域，不需要同步
        // 以下代码出现同步
        // 开启锁，数据同步
        lock.lock();
        try {
            double after = balance - money;
            balance = after;
            System.out.println(Thread.currentThread().getName() +
                    "取款成功，取款: "+money+"元，余额是: "+this.getBalance()+"元");
        } finally {
            // 关闭锁
            lock.unlock();
        }

        // ----非访问数据区域，不需要同步

        // 两天线程能够同时进来访问资源，但资源的操作时非同步的，一个线程执行完解锁后另一个线程才能获得锁从而执行
        // 加Lock类锁后，输出：
        // thread1来取钱了
        // thread2来取钱了
        // thread1取款成功，取款: 1000.0元，余额是: 4000.0元
        // thread2取款成功，取款: 1000.0元，余额是: 3000.0元
    }
}