开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Java学习第十章(一) -> 正文阅读

[Java知识库]Java学习第十章(一)

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P757 - P796

1.多线程基础

1.1 概念

进程：一个应用程序【1个进程是一个软件】
线程：一个进程中的执行场景/执行单元
一个进程可以启动多个线程

举例：
对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后
1.会先启动JVM，而JVM就是一个进程
2.JVM再启动一个主线程调用main方法
3.同时再启动一个垃圾回收线程负责看护，回收垃圾
最起码，现在的java程序中至少有两个线程并发：一个是垃圾回收线程，一个是执行main方法的主线程

1.2 进程和线程的关系

进程可以看做是现实生活当中的公司
线程可以看做是公司当中的某个员工
进程A和进程B的内存独立不共享
在java语言中，线程A和线程B，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间互不干扰，各自执行各自的，这就是多线程并发
多线程机制目的就是为了提高程序的处理效率
使用多线程机制之后，main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈

在这里插入图片描述

1.3 多线程并发

对于多核的CPU电脑来说，真正的多线程并发是没问题的
如：4核CPU表示同一个时间点上，可以真正的有4个进程并发执行
真正的多线程并发：t1线程执行t1的；t2线程执行t2的；t1不会影响t2，t2不会影响t1
单核的CPU表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人的感觉是：多个事情同时在做！！！

问题：分析以下程序，有几个线程，除垃圾回收线程之外

package thread;

public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    private static void m3() {
        System.out.println("m3 execute!");
    }
}

答：1个线程(因为程序只有1个栈)
在这里插入图片描述

2.多线程实现

java语言中，实现线程有两种方式

第一种：编写一个类，直接继承java.lang.Thread，重写run方法
注释：java支持多线程机制，并且java已经将多线程实现了，程序员只需要继承就行

//定义线程类
public class MyThread extends Thread{
     public void run(){
     }
}
//创建线程对象
MyThread t = new MyThread();

//启动线程
t.start();

第二种：编写一个类，实现java.lang.Runnable接口，实现run方法

//定义线程类
public class MyRunnable extends Runnable{
     public void run(){
     }
}
//创建线程对象
Thread t = new Thread(new MyRunnable());

//启动线程
t.start();

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活

2.1 实现线程的第一种方式

package thread;

public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行
        //新建一个分支线程对象
        MyThread t = new MyThread();
        //启动线程
        //start()方法的作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码认为完成之后，瞬间就结束了
        //这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了，线程就启动成功了
        //启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
        //run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的
        t.start();
        //这里的代码还是运行在主线程中
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中(分支栈)
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);
        }
    }
}

运行结果：
在这里插入图片描述

package thread;

public class ThreadTest02 {
    public static void main(String[] args) {
        //这里是main方法，这里的代码属于主线程，在主栈中运行
        //新建一个分支线程对象
        MyThread t = new MyThread();
        //启动线程
        t.run();//不会启动线程，不会分配新的分支栈(这种方式就是单线程)
        //这里的代码还是运行在主线程中
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        //编写程序，这段程序运行在分支线程中(分支栈)
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程---->" + i);
        }
    }
}

运行结果：

在这里插入图片描述

2.2 run和start的区别

run方法的示意图：

在这里插入图片描述
start方法的示意图：

在这里插入图片描述

2. 3 实现线程的第二种方式

package thread;

public class ThreadTest03 {
    public static void main(String[] args) {
        //创建一个可运行的对象
        MyRunnable r = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread t = new Thread(r);

        //将上面两个代码合并
        //Thread t = new Thread(new MyRunnable());

        //启动线程
        t.start();

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

//这并不是一个线程类，是一个可运行的类，它还不是一个线程
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("分支线程--->" + i);
        }
    }
}

运行结果：

在这里插入图片描述

2.4 采用匿名内部类实现线程

package thread;

public class ThreadTest04 {
    public static void main(String[] args) {
        //创建线程对象，采用匿名内部类方式
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("t线程--->" + i);
                }
            }
        });
        
        //启动线程
        t.start();

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

    }
}

运行结果：

在这里插入图片描述

3.线程生命周期

在这里插入图片描述

4.获取线程信息

获取线程对象的名字： String name = 线程对象.getName()；
修改线程对象的名字：线程对象.setName(“线程名字”)；
当线程没有设置名字的时候，默认名字为：Thread-0，Thread-1，Thread-2…
获取当前线程对象：static Thread currentThread()

Thread t = Thread.currentThread();

演示代码：

package thread;

public class ThreadTest05 {

    public void doSome(){
        //这样不行
        //this.getName;
        //super.getName;
        //这样可以
        String name = Thread.currentThread().getName();
        System.out.println("----->" + name);
    }
    public static void main(String[] args) {

        ThreadTest05 tt = new ThreadTest05();
        tt.doSome();

        //currentThread就是当前线程对象
        //这个代码出现在main方法当中，所以当前线程就是主线程
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName());//输出为：main
        //创建线程对象
        MyThread2 t1 = new MyThread2();
        //设置线程的名字
        t1.setName("t1");
        //获取线程的名字  默认名字为Thread-0
        String tName = t1.getName();
        System.out.println(tName);
        //启动线程
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("t2");
        System.out.println(t2.getName());
        t2.start();
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //currentThread就是当前线程
            //当t1线程执行run方法，那么这个当前线程就是t1
            //当t2线程执行run方法，那么这个当前线程就是t2
            Thread currentThread = Thread.currentThread();
            System.out.println(currentThread.getName() + "-->" + i);

            //super this也可以 因为当前类碰巧是线程类
            //System.out.println(super.getName() + "-->" + i);
            //System.out.println(this.getName() + "-->" + i);
        }
    }
}

运行结果：

在这里插入图片描述

5.线程的sleep方法

关于线程的sleep方法：static void sleep(long millis)

静态方法：Thread.sleep(1000)
参数是毫秒
作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用
例如：这行代码出现在A线程中，A线程就会进入休眠；这行代码出现在B线程中，B线程就会进入休眠
Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次

实例代码一：

package thread;

public class ThreadTest06 {
    public static void main(String[] args) {
        //让当前线程进入休眠，睡眠5秒
        //当前线程是主线程

        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //五秒之后执行这里的代码
        System.out.println("hello world!");
    }
}

实例代码二：

package thread;

public class ThreadTest06 {
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);

            //睡眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.1 面试题

下面代码会让线程t进入休眠状态吗？

package thread;

public class ThreadTest07 {
    public static void main(String[] args) {
        //创建线程对象
        Thread t = new MyThread3();
        t.setName("t");
        t.start();

        //调用sleep方法
        try {
            //在执行下面的代码的时候还是会转换成：Thread.sleep(1000 * 5)
            //下面代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠
            //下面代码出现在main方法中，main线程睡眠
            t.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //5秒之后这里才会执行
        System.out.println("hello world!");
    }
}

class MyThread3 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

答：不会！

5.2 终止线程的睡眠

sleep睡眠太久了，如果希望半道上醒来，应该怎么办？也就是说怎么叫醒一个正在睡眠的线程？
注意：这个不是终断线程的执行，是终止线程的睡眠

package thread;

public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        //希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了）
        try {
            Thread.sleep(1000* 5 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终断t线程的睡眠【这种终断睡眠的方式依靠了java的异常处理机制】
        t.interrupt();//干扰，一盆冷水过去！
    }
}

class MyRunnable2 implements Runnable{

    //重点：run()当中的异常不能throws，只能try catch
    //因为run()方法在父类中没用抛出任何异常，子类不能比父类抛出更多的异常
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->begin");
        //睡眠1年
        try {
            Thread.sleep(1000 * 60 * 60 * 24 * 365);
        } catch (InterruptedException e) {
            //打印异常信息
            e.printStackTrace();
        }
        //1年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "--->end");

        //调用doOther
//        try {
//            doOther();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }

    //其他方法可以throws
//    private void doOther() throws Exception{
//    }
}

运行结果：

在这里插入图片描述

5.3 强行终止线程的执行

stop()方式存在很大的缺点：容易丢失数据，因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失，不建议使用

package thread;

public class ThreadTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnalbe3());
        t.setName("t");
        t.start();

        //模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //5秒之后强行终止t线程
        t.stop();//已过时（不建议使用）
    }
}

class MyRunnalbe3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

在这里插入图片描述

5.4 合理终止线程的执行

package thread;

public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunnalbe4 r = new MyRunnalbe4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        //模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终止线程
        //你想要什么时候终止t的执行，那么你把标记修改为false，就结束了
        r.run = false;

    }
}

class MyRunnalbe4 implements Runnable {

    //打一个布尔标记
    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                //return就结束了，你在结束之前还有什么没保存的，在这里可以保存
                //save...
                
                //终止当前线程
                return;
            }
        }
    }
}

6.线程调度

6.1 概述

常见的线程调度模型：

线程调度模型	备注
抢占式调度模型	那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些，java采用的就是抢占式调度模型
均分式调度模型	平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样，平均分配，一切平等【有一些编程语言，线程调度模型采用的式这种方式】

java中提供了和线程调度有关的方法：

方法	类别	概念
void setPriority(int newPriority)	实例方法	设置线程的优先级
int getPriority( )	实例方法	获取线程优先级
static void yield()	静态方法	让位方法
void join()	实例方法	合并线程

6.2 线程优先级

实例方法：
void setPriority(int newPriority)设置线程的优先级
int getPriority( ) 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些（但也不完全是，大概率是多的）

package thread;

public class ThreadTest11 {
    public static void main(String[] args) {
        System.out.println("最高优先级：" + Thread.MAX_PRIORITY);//输出为：最高优先级：10
        System.out.println("最低优先级：" + Thread.MIN_PRIORITY);//输出为：最低优先级：1
        System.out.println("默认优先级：" + Thread.NORM_PRIORITY);//输出为：默认优先级：5

        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName() +  "线程的默认优先级是：" + currentThread.getPriority());//输出为：main线程的默认优先级是：5

        Thread t = new Thread(new MyRunnable5());
        t.setName("t");
        t.start();
    }
}

class  MyRunnable5 implements Runnable{
    @Override
    public void run() {
        //获取线程优先级
        System.out.println(Thread.currentThread().getName() + "线程的默认优先级是：" + Thread.currentThread().getPriority());
    }
}

运行结果：

在这里插入图片描述

package thread;

public class ThreadTest11 {
    public static void main(String[] args) {
        //设置主线程的优先级为1
        Thread.currentThread().setPriority(1);

        Thread t = new Thread(new MyRunnable5());
        t.setPriority(10);
        t.setName("t");
        t.start();

        //优先级较高的，只是抢到的CPU时间片相对多一些
        //大概率方向更偏向于优先级比较高的
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

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

运行结果：

在这里插入图片描述

6.3 线程让位

静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法，让当前线程让位，让给其它线程使用
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”
注意：在回到就绪之后，有可能还会再次抢到

package thread;

public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable6());
        t.setName("t");
        t.start();

        for (int i = 1; i <= 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class MyRunnable6 implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            //每100个让位一次
            if (i % 100 == 0){
                Thread.yield();//当前线程暂停一下，让给主线程
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

运行结果：

在这里插入图片描述

6.4 线程合并

实例方法：
void join()
合并线程

class MyThread1 extends Thread{
   public void doSome(){
      MyThread2 t = new MyThread2();
      t.join();//当前线程进入阻塞，t线程执行，直到t线程结束，当前线程才可以继续
  }
}

class MyThread2 extends Thread{
}

package thread;

public class ThreadTest13 {
    public static void main(String[] args) {
        System.out.println("main begin");
        Thread t = new Thread(new MyRunnable7());
        t.setName("t");
        t.start();

        //合并线程
        try {
            t.join();//t合并到当前线程中当前线程受阻塞，t线程执行直到结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main over");

    }
}

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

运行结果：

在这里插入图片描述

7.线程安全

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等等，都已经实现完了，这些代码我们都不需要编写

注意：程序员要知道，自己编写的程序需要放到一个多线程的环境下运行，更需要关注的是这些数据在多线程并发的环境下是否是安全的。

7.1 线程不安全条件

下面时刻数据在多线程并发的环境下会存在安全问题：

条件1：多线程并发
条件2：有共享数据
条件3：共享数据有修改的行为

满足以上3个条件之后，就会存在线程安全问题
在这里插入图片描述

7.2 解决线程安全问题

当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题
解决方案：线程排队执行（不能并发）
用排队执行解决线程安全问题，这种机制被称为：线程同步机制【专业术语：线程同步，实际上就是线程不能并发了，线程必须排队执行】
备注：线程同步就是线程排队，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，才可以谈效率，数据不安全，就没有效率的事了

7.3 同步和异步

异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁【其实就是：多线程并发(效率较高)】
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型，效率较低，线程排队执行

总结：异步就是并发，同步就是排队

7.4 编程模拟（不使用线程同步机制）

不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题
编写程序模拟两个线程同时对同一个账户进行取款操作

银行账户：

package threadsafe;

public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    public Account() {
    }

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

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    //取款的方法
    public void withdraw(double money){
        //t1和t2并发这个方法（t1和t2是两个栈，两个栈操作堆中同一个对象）
        //取款之前的余额
        double before = this.getBalance();
        //取款之后的余额
        double after = before - money;

        //在这里模拟一下网络延迟，100%会出问题
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //更新余额
        //t1执行到这里，但还没有来得及执行这行代码，t2线程进来withdraw方法了，此时一定出问题
        this.setBalance(after);
    }
}

账户线程：

package threadsafe;

public class AccountThread extends Thread{
    //两个线程必须共享同一个账户对象
    private Account act;

    //通过构造方法传递过来账户对象

    public AccountThread(Account act) {
        this.act = act;
    }

    @Override
    public void run() {
        //run方法的执行表示取款操作
        //假设取款5000
        double money = 5000;
        //取款
        //多线程并发执行这个方法
        act.withdraw(money);

        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money +"成功，余额" + act.getBalance());
    }
}

测试类：

package threadsafe;

public class Test {
    public static void main(String[] args) {
        //创建账户对象(只创建1个)
        Account act = new Account("act-001",10000);

        //创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);

        //设置name
        t1.setName("t1");
        t2.setName("t2");

        //启动线程取款
        t1.start();
        t2.start();
    }
}

运行结果：

在这里插入图片描述

7.5 编程模拟（使用线程同步机制）

使用线程同步机制，解决线程安全问题

线程同步机制语法：

synchronized (){
    //线程同步代码块
}

synchronized()后面小括号中传的这个“数据”是相当关键的，这个数据必须是多线程共享的数据，才能达到多线程排队
()中写什么？

那要看程序员想让哪些线程同步。
假设t1、t2、t3、t4、t5，有5个线程，只希望t1、t2、t3排队，t4、t5不需要排队
程序员一定要在()中写一个t1、t2、t3共享的对象，而这个对象对于t4、t5来说不是共享的

银行线程和测试类不变

银行账户：

package threadsafe2;

public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    public Account() {
    }

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

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    //取款的方法
    public void withdraw(double money){
        //以下这几行代码必须是线程排队的，不能并发
        //一个线程把这里的代码全部执行结束之后，另一个线程才能进来
        //这里的共享对象是：账户对象
        //账户对象是共享的，那么this就是账户对象
        //不一定是this，这里只要是多线程共享的那个对象就行
        //最好使用this，因为this会灵活的变动
        synchronized (this){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

    }
}

7.6 synchronized理解

在java语言中，任何一个对象都有“―把锁”，其实这把锁就是标记。(只是把它叫做锁)
100个对象，100把锁。1个对象1把锁。

以下代码的执行原理?

synchronized (this){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
2、假设t1先执行了，遇到了synchronized，这个时候自动找"后面共享对象"的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后,进入同步代码块执行程序。
4、这样就达到了线程排队执行

注意：这个共享对象一定要选好，这个共享对象一定是你需要排队执行的这些线程对象所共享的

7.7 编程模拟

银行线程和测试类不变

银行账户变形一：
定义全局对象

package threadsafe2;

public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    //对象
    Object obj = new Object();//实例变量(Account对象是多线程共享的，其中的实例变量obj也是共享的)

    public Account() {
    }

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

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    //取款的方法
    public void withdraw(double money){
        synchronized (obj){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

    }
}

总结：此时也可以达到this一样的效果

银行账户变形二：
定义局部对象

package threadsafe2;

public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    public Account() {
    }

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

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    //取款的方法
    public void withdraw(double money){
        Object obj2 = new Object();
        synchronized (obj2){//这样编写就不安全了，因为obj2不是共享对象
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

    }
}

运行结果：

在这里插入图片描述
总结：局部变量定义的对象就不符合要求

银行账户变形三：
定义常量对象，因为"abc"在字符串常量池中
此时所有的线程都会同步，例如t1、t2、t3、t4、t5都会同步

package threadsafe2;

public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    public Account() {
    }

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

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    //取款的方法
    public void withdraw(double money){
        synchronized ("abc"){
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }

    }
}

7.8 有线程安全问题的变量

Java中的三大变量：

实例变量：在堆中
静态变量：在方法区中
局部变量：在栈中

局部变量永远不会存在线程安全问题，因为局部变量在栈中(一个线程一个栈)，所以局部变量永远都不会共享
实例变量在堆中，堆只有1个；静态变量在方法区中，方法区也只有1个；堆和方法区都是多线程共享的，所以可能存在线程安全问题
局部变量+常量：不会有线程安全问题
成员变量【实例变量+静态变量】：可能会有线程安全问题

7.9 扩大同步范围

同步代码块越小效率越高
测试类不变，将银行账户中的同步放到银行线程中

package threadsafe2;

public class AccountThread extends Thread{
    //两个线程必须共享同一个账户对象
    private Account act;

    //通过构造方法传递过来账户对象

    public AccountThread(Account act) {
        this.act = act;
    }

    @Override
    public void run() {
        //run方法的执行表示取款操作
        //假设取款5000
        double money = 5000;
        //取款
        //多线程并发执行这个方法
        synchronized(act){
        act.withdraw(money);//这种方式也可以，只不过扩大了同步的范围，效率更低了
        }
        System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money +"成功，余额" + act.getBalance());
    }
}

7.10 synchronized出现在实例方法上

在实例方法上可以使用synchronized
缺点：

但是一定锁的是this，不能是其它的对象，这种方式不灵活
synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低，所以这种方式不常用

优点：

代码写的少了，节俭了

注意：如果共享的对象是this，并且需要同步的代码块是整个方法，建议使用这种方式

 public synchronized void withdraw(double money){
        double before = this.getBalance();
        double after = before - money;

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBalance(after);
    }

注意：
如果使用局部变量的话，建议使用：StringBuilder
因为局部变量不存在线程安全问题，选择StringBuilder，而StringBuffer效率比较低

属性	是否非线程安全
ArrayList	非线程安全
Vector	线程安全
HashMap/HashSet	非线程安全
Hashtable	线程安全

7.10 synchronized总结

synchronized有三种写法：

同步代码块：灵活

synchronized(线程共享对象){
    同步代码块;
}

在实例方法上使用synchronized，表示共享对象一定是this，并且同步代码块是整个方法体
在静态方法上使用synchronized，表示找类锁，类锁永远只有1把，就算创建了100个对象，那类锁也只有一把

注意：

对象锁：1个对象1把锁，100个对象100把锁
类锁：100个对象，也可能只是1把类锁

8.synchronized面试题

8.1 面试题一

问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：不需要，因为doOther方法没有synchronized

package exam1;

public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);//这个睡眠的作用是：为来保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread{
    private MyClass mc;

    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }

        if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}
class MyClass{
    //synchronized出现在实例方法上，表示锁this
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

8.2 面试题二

问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：需要，因为doOther方法也有synchronized

package exam1;

public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);//这个睡眠的作用是：为来保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread{
    private MyClass mc;

    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }

        if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}
class MyClass{
    //synchronized出现在实例方法上，表示锁this
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

8.3 面试题三

问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：不需要，因为MyClass对象是两个，两把锁

package exam3;

public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);//这个睡眠的作用是：为来保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread{
    private MyClass mc;

    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }

        if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass{
    //synchronized出现在实例方法上，表示锁this
    public synchronized void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

8.4 面试题四

问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把

package exam4;

public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        Thread.sleep(1000);//这个睡眠的作用是：为来保证t1线程先执行
        t2.start();

    }
}

class MyThread extends Thread{
    private MyClass mc;

    public MyThread(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }

        if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }
    }
}

class MyClass{
    //synchronized出现在静态方法上，是找类锁
    public synchronized static void doSome(){
        System.out.println("doSome begin");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over");
    }

    public synchronized static void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}