线程学习(2)线程创建,等待,安全,synchronized

 "i need your breath"

作者:Mylvzi 

 文章主要内容:线程学习(2) 

前情回顾:

  在上一篇博客中介绍到了进程与线程的区别,以及初步了解如何在Java实现多线程编程,通过内置的Thread类来实现多线程,充分利用多核cpu资源,要充分认识到每一个线程都是一个独立的"执行流",本篇文章继续讲解和Thread有关的一些操作

一.Thread类的创建方式

1.继承Thread  重写run

//创建一个类  继承于Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程的入口  告诉线程要执行哪些逻辑

            System.out.println("hello thread");
            try {
                // 休眠1s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 首先要实例化出一个Thread类
        Thread thread = new MyThread();
//         start和run都是Thread类的成员
//         run只是告诉线程要去执行那些逻辑
//         start是真正的调用系统的api,创建出一个线程,再让线程去执行run
        thread.start();
//        thread.run();
        while (true) {
            System.out.println("hello main");
            // 休眠1s
            Thread.sleep(1000);
        }
    }
}

2.实现Runnable  重写run

  创建自定义类时让其实现Runnable接口,这样写的原因本质在于Thread类也实现了Runnable接口

class MyThread implements Runnable {
    @Override
    public void run() {

        while(true) {
            System.out.println("==");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        // 使用向上转型 是Java生态中的常见方式
        
        // 先实现一个Runnable接口
        Runnable runnable = new MyThread();
        Thread thread = new Thread(runnable);
        thread.start();

        while (true) {
            System.out.println("==");
            Thread.sleep(1000);
        }
    }
}

说明:

Runnable表示的是一个"可以运行的任务",这个任务是交给线程执行还是交给其他是体执行,Runnable本身并不关心~

Runnable接口用来表示一个可以在线程中单独执行的任务,一个类只要实现了Runnable接口并且实现他的run方法,那么这个类的实例就能够单独在线程中执行,Runnable接口就像是一个点石成金的"魔法师",只要被他修饰过,就具有了"可被执行"的属性,这个任务不仅仅可以通过线程来执行,也可以通过线程池和执行器来执行

使用Runnable接口有哪些好处呢?直接继承Thread类不是更简单么?使用Runnable接口最大的好处就是可以"解耦合",降低代码之间的联系性,代码之间的联系性越高,耦合度就越高;反之亦然,耦合度过高不利于我们之后对代码进行修改~就像你和你最好的哥们一起创业,分钱肯定是不好分的~

上述两种创建Thread类的方式有所不同,第一种是直接通过MyThread类来实例化一个Thread类,第二种是先通过MyThread类先实例化一个Runnable接口,再通过这个接口去实例化一个Thread类。为什么第二种方式耦合度更低呢?原因在于第二种方式自定义类和Thread类之间的联系性降低了,他们之间是通过Runnable接口来联系起来的,以后使用更多线程的时候就都可以通过Runnable这个接口来实现,请看第二种方式创建线程的图解

线程学习(2)线程创建,等待,安全,synchronized_第1张图片

第一种方式的图解

线程学习(2)线程创建,等待,安全,synchronized_第2张图片

很明显第二种方式代码之间的耦合性更低

3.继承Thread,重写run,使用匿名内部类

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        // 继承Thread  使用匿名内部类
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

4.实现Runnable  重写run,使用匿名内部类

public class Demo11 {
    public static void main(String[] args) {
        // 实现Runnable  重写run  使用匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        
        Thread t = new Thread(runnable);
        t.start();
    }
}

5.使用lambda表达式+Runnable接口(推荐方式)

Runnable接口是一个函数式接口,只有一个抽象方法run,所以可以使用lambda表达式来实现

public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        // 使用lambda表达式
        Runnable runnable = () -> {
            while (true) {
                System.out.println("Mythread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();

        while (true) {
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

使用这种方式创建线程,代码既简洁,又优雅,耦合性也低,推荐大家使用这种方式创建线程

Thread类的其他构造方法

Thread(String name) 创建线程对象,并命名

这个构造方法主要用于给线程命名,方便后续进行调试

        // 可以为线程起一个名字作为标识  对线程的执行没有影响  就是单纯的一个"标识"  方便之后调试进行检查区分
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"这是一个线程名字");

Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象,并命名 【了解】Thread(ThreadGroup group, Runnable target) 线程可以被用来分组管理,分好的组即为线程组

二.Thread类的一些属性

1.ID

线程的唯一标识,是Java为每个线程分配的"身份标识"

获取方法

getId() 

        Thread t = new Thread();
        long tid = t.getId();// 返回值是一个长整型
        System.out.println("线程ID:" + tid);// 输出线程ID:20

2.名称name

就是线程的名字,便于后序进行调试

获取方法

getName()

        Thread t = new Thread("我是线程");
        String tName = t.getName();
        System.out.println(tName);// 输出我是线程

注意:此方法在源码中是被final修饰的,意味着子类无法重写方法

3.状态 state

进程最常见的两种状态是就绪状态和阻塞状态,线程也有自己的一些属性

        // 获取线程的所有状态
        for (Thread.State state : Thread.State.values()) {
            System.out.print(state+" ");
        }

  • NEW  Thread  对象已经存在 但是还没有通过start方法调用
  • RUNNABLE  就绪状态  线程已经在cpu上执行/等在在cpu上执行
  • TERMINATED  Thread对象还在  但系统内核中的线程不存在
  • TIMED_WAITING  阻塞 由于sleep这种固定时间的方式产生的阻塞
  • WAITING  阻塞 由于wait这种不固定时间的方式产生的阻塞
  • BLOCKED  阻塞  由于锁竞争导致的阻塞
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        });

        System.out.println(t.getState());// Thread类存在,但是还没有调用start方法,状态为NEW
        t.start();
        System.out.println(t.getState());// RUNNABLE
        Thread.sleep(3000);
        System.out.println(t.getState());// TERMINATED

4.优先级priority

获取线程的优先级

获取方法

getPriority

        Thread t = new Thread("我是线程");
        int tPriority = t.getPriority();
        System.out.println(tPriority);

说明:其实此方法很"鸡肋",因为线程的优先级是由cpu的调度器决定的,在我们写代码的过程中很少去关注优先级,一是我们根本就观察不到,二是根本也没这个必要

5.是否是后台线程

线程可以分为两类,前台线程和后台线程,默认情况下是前台线程。后台线程又叫做"守护线程",就像一场表演的后台工作人员一样,对于后台线程来说,后台线程不结束,不影响整个进程的结束(表演完了,可后台人员还需要处理后事,他们的工作还没结束),而对于前台线程来说,一个Java程序中,如果还有前台进程没有结束,则整个进程是一定不会结束的

获取方法

isDaemon

        // 源码规定   默认是前台线程
        /* Whether or not the thread is a daemon thread. */
        private boolean daemon = false;

        Thread t = new Thread("我是线程");
        boolean isDaemon = t.isDaemon();
        System.out.println(isDaemon);// 输出false

代码验证

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();// 默认是前台线程  持续打印hello thread
    }

对于这个代码来说,主线程中没有要执行的语句,也就是说他的主线程是在一瞬间就执行完了,但是由于t是前台线程,前台线程不结束整个进程就不会结束,如果将t设置为后台线程呢

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        
        // 在线程开启前将其设置为后台线程  
        t.setDaemon(true);
        t.start();
    }

 

可以看到什么也没有打印。因为主线程是前台线程,飞快执行完毕之后没有其他的前台线程,整个进程终止,也就是说t线程没来得及执行,整个进程就结束了。也就是说只要一个进程中的所有前台线程结束,就代表整个进程的结束

验证,先让主线程休眠3s,3s之后主线程会立即结束,尽管t线程内部还有语句没有执行,由于前台线程的结束,导致整个进程结束

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {

                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("hello thread");
            }
        });

        // 在线程开启前将其设置为后台线程
        t.setDaemon(true);
        t.start();
        System.out.println("主线程开启");
        Thread.sleep(3000);
    }

 6.是否存活

  判断内核线程是否还存活

在Java中我们通过Thread类来创建出一个线程,但实际上Thread类的生命周期要比内核中的线程要长一些,也就是说线程已经不存在了,但是你创建的Thread类仍然存在,使用isAlive判定内核线程是否已经结束

isAlive()

    public static void main(String[] args) throws InterruptedException {
        // 创建一个线程
        Thread t = new Thread(() -> {
            System.out.println("线程开始");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("线程结束");
        });
        
        // 开启线程
        t.start();
        System.out.println(t.isAlive());// 输出true
        Thread.sleep(3000);
        System.out.println(t.isAlive());// 输出false
    }

 线程t内部的方法我们称之为回调方法,当回调方法执行完毕之后,就代表t这个线程的终止,但是Thread类对象的生命周期并未结束

        System.out.println(t.isAlive());// 输出false

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

如果在线程开启之前打印,输出false,因为此时t线程还没有被创建

 三.线程的中断

终止/打断  interrupt

在Java中要想销毁/中断一个线程的方法是比较唯一的,

就是想办法让run方法尽快执行完毕

那么如何实现呢?这里提供两种方法

1.手动设置标志位,来作为run方法结束的条件

很多线程之所以会持续很久,是因为run方法内部存在循环,结束run方法就是终止循环

    // 将标志位设置为类变量
    private static boolean isQuit = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("Thread is working");
            }
        });

        t.start();

        // 五秒后改变标志位
        Thread.sleep(2000);
        isQuit = true;

    }

通过设置标志位,并在主线程中修改标志位,这样就实现了在5秒之后中断此线程的效果

注意:

1.isQuit不能设置为main方法中的局部变量,因为在lambda表达式中使用的变量必须是被final修饰的常量,如果设置为局部变量,就无法再次更改isQuit,导致无法结束循环。

2.将isQuit设置为"类变量",lambda表达式此时访问这个成员就不再是变量捕获了,而是内部类访问外部类这个语法了。此时就没有final的限制

上述方法虽然能够结束run方法,但是过于繁琐,且不优雅,需要人为的手动设置标志位,同时,如果在主线程中我们改变了标志位的值,但是此时线程却在sleep,那就只能等到线程再次苏醒才能终止该线程,所以说通过设置标志位的方法来终止线程还有反应不及时的问题

2.使用Thread内部自带的"标志位"

  其实在Thread类中,有自带的标志位isInterrupted,默认是false

    public static void main(String[] args) throws InterruptedException {
        Thread t= new Thread(() -> {
            // 先获取当前Thread的实例  在判断其自带的标志位isInterrupted
            while (!Thread.currentThread().isInterrupted()) {
                while (true) {
                    System.out.println("Thread is working");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t.start();
        Thread.sleep(3000);
        // 此方法就是将自带的标志位isInterrupted设置为true
        t.interrupt();
    }

通过t.interrupt()方法将标志位设置为true来终止线程,这种方法的一个优点是即使线程内部处于"阻塞"状态(sleep),也能够强制将其唤醒,终止run方法,反应更加及时 

总结:两种中断线程的方法逻辑都是一样的,即设置合适的标志位,并修改该标志位来终止run方法,从而终止整个线程,但是更加推荐第二种方法

但是上述代码的运行结果是什么呢?请看

线程学习(2)线程创建,等待,安全,synchronized_第3张图片

异常被抛出且被捕获,但是t线程仍在工作,并没有发生中断,这是为什么呢?通过interrupt方法唤醒线程之后,此时sleep方法会抛出异常,同时自动清除刚才设置的标志位,相当于白白设置标志位了,为什么要这么做呢?是为了让我们有更多的操作空间,在捕获到异常之后,我们可以自由采用以下三种处理方式

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // 1.方式1  不管不顾  让t线程继续运行
                        e.printStackTrace();

                        // 2.方式2 使用break直接中断进程
                        // 3.方式3  捕获到线程之后处理其他工作的代码
                        // 此处就存放需要解决的其他工作的代码
                    }

四.线程的等待

  一个线程等待另一个线程执行结束,再继续执行。线程等待的本质是控制线程结束的顺序

在Java中使用join来实现线程等待效果

主线程中使用join,就是主线程等待另一个线程结束再继续执行主线程的其余代码

    public static void main(String[] args) throws InterruptedException {
        Thread t= new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程工作中!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });


        t.start();
        System.out.println("线程开启");
        t.join();// 让主线程等待t线程
        System.out.println("线程结束");
    }

线程学习(2)线程创建,等待,安全,synchronized_第4张图片

t.join()的工作过程

  1. 如果t线程还没有结束,就让主线程等待t线程执行结束,再去执行主线程中剩余的代码,此时主线程就是一个"阻塞"状态
  2. 如果t线程已经结束了,直接返回,不存在"阻塞状态"

在哪个线程中调用join方法就是让哪个线程等待另一个线程

线程学习(2)线程创建,等待,安全,synchronized_第5张图片

说明:join方法默认是"死等",即如果被等待的线程没结束,就不会执行其余代码,但这种方式存在一个问题,如果被等待的线程是死循环,那其余代码就永远无法执行,在实际的开发中,我么更推荐"有时间"的等待

此处表示主线程只等待1s,1s之后就会去执行主线程中剩余代码 

线程学习(2)线程创建,等待,安全,synchronized_第6张图片

补充:关于调度开销

当我们使用Thread.sleep方法时,我们通过设置一定的时间让线程处于阻塞状态,结束之后再恢复为就绪状态,由阻塞到就绪其时间一定等于sleep的时间么

        long beg = System.currentTimeMillis();
        Thread.sleep(1000);// 休眠1s
        long end = System.currentTimeMillis();
        System.out.println("时间:" + (end - beg) + " ms");// 输出1003

 

可见由阻塞到就绪这部分的时间并不等于sleep的时间,原因在于休眠结束之后,线程并不是立马就变为就绪状态,而是需要通过调度器进行调度,而这种调度是需要时间的,这部分由于调度器调度所产生的时间就叫做调度开销

五.线程安全问题

有些代码如果只是一个线程单独去执行,执行结果是完全正确的

但是,同样的代码,如果使用多个线程同时去执行,执行结果就可能产生问题,这种就是"线程安全问题"/"线程不安全"

比如我们要对一个数使其自增1w,如果只使用一个线程来解决,其结果一定正确

    public static void main(String[] args) {
        // 在主线程中单独执行
        int cnt = 0;
        for (int i = 0; i < 10000; i++) {
            cnt++;
        }

        System.out.println(cnt);// 输出10000
    }

如果使用两个线程实现这个目标,则应该是一个线程自增5000次,加起来一共自增1w次

    private static int cnt = 0;
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                cnt++;
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                cnt++;
            }
        });
        
        // 线程开启
        t1.start();
        t2.start();
        
        // 让主线程等待两个线程结束
        t1.join();
        t2.join();
        
        // 输出打印
        System.out.println(cnt);// 输出7351
}

最后的打印结果是一个莫名其妙的数,不是我们想的1w,如果继续重复尝试,发现每次打印的结果还都不相同 ,程序出现bug了,这种问题就是在并发编程中常遇到的线程安全问题

线程学习(2)线程创建,等待,安全,synchronized_第7张图片

为什么会出现这种问题呢,此时就要深入底层去看下cnt++这个操作是如何实现的

cnt++的实现在底层中分为三步

  1. load 把数据从内存中 读取到cpu寄存器中
  2. add 把寄存器中的数据+1
  3. save  把寄存器中的数据,保存到内存之中 

线程学习(2)线程创建,等待,安全,synchronized_第8张图片

站在cpu的角度,cnt++这个操作分别对应着三条cpu指令,是由这三条指令实现的~

如果使用多线程来执行上述代码,由于线程之间的调度顺序是随机的,就会导致在一些调度顺序下发生错误,下面来看都有哪些可能的调度顺序

线程学习(2)线程创建,等待,安全,synchronized_第9张图片

可以看出,调度顺序的种类其实是无数种!!!一是调度操作的逻辑顺序,二是每个线程执行多少次我们并不知道,在图中,只有前两种的调度顺序才能达到我们想要的结果,下面以一个反例来验证其他顺序的错误

线程学习(2)线程创建,等待,安全,synchronized_第10张图片

由于线程调度的随机性,也就说上述调度顺序也是随机的,所以最终产生的结果也是随机的(但是最终的结果一定比1w小,因为只有前两种调度顺序才能实现数字的正确增加) 

那一定比5000大么,这也是不一定的,如果在t1自增一次的过程中,t2自增了两次,一共消耗了三次自增,但实际上只自增了一次,如果这种逻辑顺序占多数,就有可能出现<5000的情况

线程学习(2)线程创建,等待,安全,synchronized_第11张图片

产生线程安全问题的原因

  1.  操作系统中,线程的调度顺序是随机的(抢占式执行) 罪魁祸首
  2. 多个线程,针对同一个变量进行修改(上述例子就是)
  3. 修改操作不是原子的,cnt++这个操作是分三步执行的,不是原子的。什么是原子的呢》比如存在一个cpu指令能同时完成cnt++的三个操作
  4. 内存可见性问题
  5. 指令重排序问题

说明:

对于第二种原因,改变一些描述就不是线程安全问题了

  • 一个线程,针对同一个变量进行修改  ok
  • 多个线程,针对不同的变量进行修改  ok
  • 多个线程,针对不同的变量进行读取  ok 

通过加锁就能解决上述问题

六.锁 synchronized

1.基本概念

  如何给Java的代码进行加锁呢?其中最常用的方法是通过synchronized关键字(最好还是掌握下他的发音和含义)

线程学习(2)线程创建,等待,安全,synchronized_第12张图片

synchronnized在使用的时候需要搭配{}来使用,进了{}就相当于"加锁",出了{}就是"解锁",在已经加锁的状态下,如果另一个线程也尝试同样加这个锁,就会发生"锁竞争"/"锁冲突",后一个线程就会阻塞等待

加锁,我们要明确是给谁加锁,也就是要对具体的对象进行加锁,只有当两个线程针对同一个对象进行加锁,才会发生冲突,针对不同的对象加锁,就不会发生冲突(可以把加锁理解为确立男女朋友关系,一旦确立(加锁),就不允许其他人再进入了,除非原先的关系破裂(解锁),不能脚踏两只船~~~)

代码实现:

        // 锁竞争的对象
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                // 使用synchronized关键字进行加锁
                synchronized(locker) {
                    cnt++;
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                // 使用synchronized关键字进行加锁
                synchronized(locker) {
                    cnt++;
                }
            }
        });

在这个代码中,我们先是创建了一个用于"加锁"的对象locker,接着进行加锁,如何加锁呢?根据上述引发线程安全的2"多个线程,针对同一个变量进行修改",我们要限制的是两个线程不能同时对同一个变量进行修改,所以应该加锁的操作是"cnt++",使用synchronized(locker){}对其进行加锁

  线程学习(2)线程创建,等待,安全,synchronized_第13张图片

这种情况是我们上述所说的会引发线程安全问题的一种调度顺序,下面看看加锁是如何解决这个问题的

线程学习(2)线程创建,等待,安全,synchronized_第14张图片

   对象存在的意义有且仅有一个,当多个线程针对同一个对象进行加锁的时候,就会发生锁冲突,一个线程拿到锁,就继续执行代码,而另一个线程没拿到锁,就会处于阻塞状态。直到另一个线程释放锁,才能继续执行剩余代码~

  这样做实际上是把"并发执行"转换为"串行执行",这样就避免了操作之间的穿插,导致错误的出现

注意:必须是多个线程针对同一个对象进行加锁,如果是不同的对象就不会发生锁冲突,也就不会出现线程阻塞

        // 锁竞争的对象
        Object locker = new Object();
        Object locker2 = new Object();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized(locker) {
                    cnt++;
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                // 此时两个线程针对的是不同的对象进行加锁  不发生锁冲突
                synchronized(locker2) {
                    cnt++;
                }
            }
        });

还是那句话,锁的对象是谁不重要,只要锁的是同一个对象就一定会引发锁冲突!!! 

2.synchronized对方法进行加锁

除了对对象加锁,synchronized还可以对方法加锁

下面先修改一下我们的代码:

class Counter {
    public static int cnt;

    // 将cnt++这个操作放到一个方法内部
    public void increment() {
        cnt++;
    }
}

 public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter.cnt);
    }

此时继续执行代码,发现结果仍然是随机值,原因在于还是出现了"两个线程同时针对同一个变量进行修改"这样的操作,解决方法就是进行加锁,此时我们可以对increment()这个方法进行加锁


    synchronized public void increment() {
        cnt++;
    }

加锁之后,只能有一个线程拥有increment(),另一个线程想要使用的话只能等前一个线程释放锁之后才能使用

 上述对方法加锁的方式还有一个等价方式

    public void increment2() {
    // 这其实是对"实例方法"进行加锁的
    // 实例方法的实现取决于实例化的对象 也就是本质上是对调用这个方法的对象进行加锁
    // 让调用方法的对象拥有这个锁
        synchronized (this) {
            cnt++;
        }
    }

同样的,synchronized还可以对"类方法进行加锁",对类方法加锁本质上就是对类对象进行加锁

    // 类方法
    synchronized public static void increment3() {
        cnt++;
    }

    public static void increment4() {
        // 这里利用到了反射
        synchronized (Counter.class) {
            cnt++;
        }
    }

 说明:类对象在一个Java文件中是唯一的,类对象中包含很多信息,比如类的属性,方法,继承关系,实现接口等等,类对象可以通过反射的方式获取

3.对象的"锁属性"是存在于对象头中的

我们知道一旦一个对象被synchronized修饰就代表该对象被上锁了,也就是说synchronized改变了对象的原有属性,而这个决定对象是否被"锁"的属性存在于"对象头"之中

  对于一个对象来说,除了其自定义的一些属性,还有一些系统为其分配的属性,这些属性的集合被称为"对象头",对象头中,就有属性用于表示对象是否被锁,以下是对象数据的组成

线程学习(2)线程创建,等待,安全,synchronized_第15张图片

4. synchronized的重要特性-可重入性

要了解可重入性,先了解什么是可重入锁,所谓的可重入锁就是指:

一个线程能够对同一个对象连续加锁两次,不会出现死锁,就是可重入。不满足,就是不可重入;

而被synchronized修饰的对象都具有可重入性,再简单来说,可重入性就是指一个线程再持有一个对象的锁之后,还可以再次对该对象加锁,举一个简单的例子

class MyClass {
    // 创建两个静态方法
    synchronized public static void methodA() {
        System.out.println("这是methodA");
        methodB();
    }

    synchronized public static void methodB() {
        System.out.println("这是methodB");
    }
    
    public static void main(String[] args) {
        // 调用类方法  此时synchronized是对类对象进行加锁
        MyClass.methodA();
    }
}

再这个例子中,主线程中我们调用了methodA,因为 methodA是被synchronized修饰的,此时主线程就持有了MyClass类对象类的锁,紧接着进入methodB,因为methodB也是synchronized修饰的,所以即便在methodA内部调用methodB,主线程也会再次获取MyClass类对象类的锁,会直接获取成功

线程学习(2)线程创建,等待,安全,synchronized_第16张图片

今天线程的学习就到这里,敬请期待后续章节 

你可能感兴趣的:(学习,java,开发语言)