多线程复习笔记（九）同步线程（中）

最新推荐文章于 2024-08-24 22:01:16 发布

洛.rar

最新推荐文章于 2024-08-24 22:01:16 发布

阅读量88

点赞数

分类专栏：多线程复习笔记文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_51606563/article/details/126695824

版权

多线程复习笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文详细讲解了Java中synchronized关键字如何实现内部锁，通过实例演示了同步代码块、实例方法与静态方法的区别，以及this关键字在锁对象选择中的作用。理解this与不同对象实例的关系对于多线程同步至关重要。

摘要由CSDN通过智能技术生成

一，内部锁：synchronized关键字

java中的每个对象都有一个与之关联的内部锁（intrinsic loock）这种锁也称为监视器（Monitor），这种内部锁是一种排他锁，可以保障原子性，可见性与有序性

内部锁是通过synchronized关键字实现的synchronize关键字修饰代码块，修饰改方法

修饰代码块的语法：

        synchronize（对象锁）{
            同步代码块
        }

修饰实例方法就称为同步实例方法

修饰静态方式就称为同步静态方法

1.1 synchronized 同步代码块

开启两个线程，让两个线程调用同一个方法

public class Text01 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text01 test = new Text01();

        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.mm();
            }
        }).start();

    }
    //定义一个方法打印一百行字符串
    public void mm(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

这样我们得到的结果会使两条线程相互穿插的都打印了一百行数据，一共两百行

如果我们希望同步代码块，即一个线程先打印完一百行数据，另一个线程再打印数据，一共两百行

 public class Text01 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text01 test = new Text01();

        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.mm();
            }
        }).start();

    }
    //定义一个方法打印一百行字符串
    public void mm(){
        //我们通常使用this 即当前对象作为锁对象
        synchronized (this){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

我们需要理解this到底值得是谁

如果代码改为如下情况，打印结果会发生变化吗？

public class Text01 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text01 test01 = new Text01();
        Text01 test02 = new Text01();


        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.mm();
            }
        }).start();

    }
    //定义一个方法打印一百行字符串
    public void mm(){
        //我们通常使用this 即当前对象作为锁对象
        synchronized (this){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

会发生变化

synchronize中的this指的是调用这个方法的对象。第一个线程与第二个线程调用mm方法的对象都不一样，无法实现同步代码块。

我们也可以使用一个常量作为锁对象

public class Text02 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text02 test01 = new Text02();
        Text02 test02 = new Text02();


        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.mm();
            }
        }).start();

    }
    public static final Object obj =new Object();
    //定义一个方法打印一百行字符串
    public void mm(){
        //我们也可以使用一个常量对象作为锁对象
        synchronized (obj){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

静态方法也可以实现

public class Text03 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text03 test01 = new Text03();
        Text03 test02 = new Text03();
        
        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                Text03.sm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                Text03.sm();
            }
        }).start();

    }
    public static final Object obj =new Object();

    public static void sm(){
        //我们也可以使用一个常量对象作为锁对象
        synchronized (obj){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

一个线程先打印一百行，另一个线程再打印

同步实例方法

public class Text04 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text04 test01 = new Text04();


        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mm2();
            }
        }).start();

    }

    //定义一个方法打印一百行字符串
    public void mm(){
        //我们通常使用this 即当前对象作为锁对象
        synchronized (this){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
    
    //定义一个方法打印一百行字符串
    //使用synchronized修飾实例方法，同步实例方法，默认this为锁对象
    public synchronized void mm2() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

同步静态方法

public class Text05 {
    public static void main(String[] args) {
        //创建两个线程分别调用mm方法
        //先创建Test实例对象通过对象名调用对象
        Text05 test01 = new Text05();
        Text05 test02 = new Text05();


        //启动第一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test01.mm();
            }
        }).start();

        //启动第二个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                test02.mm2();
            }
        }).start();

        //启动第三个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                Text05.mm2();
            }
        }).start();

    }

    //定义一个方法打印一百行字符串
    public static void mm(){
        //我们通常使用this 即当前对象作为锁对象
        synchronized (Text05.class){
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }

    //定义一个方法打印一百行字符串
    //使用synchronized修飾静态方法，同步静态方法，默认运行时类为锁对象
    public static synchronized void mm2() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}