Java多线程编程-线程安全和锁Synchronized概念

最新推荐文章于 2021-06-01 03:37:23 发布
最新推荐文章于 2021-06-01 03:37:23 发布
阅读量248 收藏
点赞数
分类专栏： 并发编程 笔试面试经
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010979642/article/details/102563177
版权

线程安全

线程安全概念：多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的， 局部变量逃逸也可能导致线程安全问题。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

 

synchronized 关键字总结

  • 静态方法的锁属于类锁， 一个类中所有加锁的静态方法共用该锁， 多个 Share 类之间锁共用
  • 非静态方法属于对象锁， 一个对象中所有加锁的非静态方法共用该锁， 多个 Share 对象实例之间互不影响
  • 对于同一个类, 类锁和对象(类的实例)锁互不影响
    • 一个加锁的静态方法执行不会影响一个加锁的非静态方法的执行.
    • 一个加锁的静态方法执行, 另一个加锁的静态方法不能执行, 要等待持有锁的线程释放.
    • 一个加锁的非静态方法执行, 另一个加锁的非静态方法不能执行, 要等待持有锁的线程释放.

 

程序验证

执行入口

public class AnswerApp {
    public static void main(String[] args) throws InterruptedException {
        Sharer sharer = new Sharer();
        ThreadA threadA = new ThreadA(sharer);
        threadA.setName("ThreadA");
        ThreadB threadB = new ThreadB(sharer);
        threadB.setName("ThreadB");
        ThreadC threadC = new ThreadC(sharer);
        threadC.setName("ThreadC");

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

class ThreadA extends Thread {
    private Sharer sharer;

    public ThreadA(Sharer sharer) {
        this.sharer = sharer;
    }

    @Override
    public void run() {
        sharer.printA();
    }
}

class ThreadB extends Thread {
    private Sharer sharer;

    public ThreadB(Sharer sharer) {
        this.sharer = sharer;
    }

    @Override
    public void run() {
        sharer.printB();
    }
}

class ThreadC extends Thread {
    private Sharer sharer;

    public ThreadC(Sharer sharer) {
        this.sharer = sharer;
    }

    @Override
    public void run() {
        sharer.printC();
    }
}

synchronized 类锁

public class Sharer {
    private final static DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	
	// Sharer 类锁
    synchronized
    public static void printA() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入同步 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开同步 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 类锁
    synchronized
    public static void printB() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入同步 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开同步 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 类锁
    public void printC() {
        synchronized (Sharer.class) {
            System.out.println(MessageFormat.format("{0} 线程=[{1}]进入同步 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(MessageFormat.format("{0} 线程=[{1}]离开同步 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        }
    }
}

运行结果输出

2019-10-15 11:19:08 线程=[ThreadA]进入 printA 方法
2019-10-15 11:19:10 线程=[ThreadA]离开 printA 方法
2019-10-15 11:19:10 线程=[ThreadC]进入 printC 方法
2019-10-15 11:19:12 线程=[ThreadC]离开 printC 方法
2019-10-15 11:19:12 线程=[ThreadB]进入 printB 方法
2019-10-15 11:19:14 线程=[ThreadB]离开 printB 方法

结论

public synchronized static void myFun() {
	// ...
}
// 等价于
public void myFun() {
	synchronized (类名.class) {
		// ...
	}
}

由程序运行结果输出得： printA、printC、printB 先后执行， 可知 三个方法共用一个锁(类锁)

 

synchronized 类锁 和对象锁

public class Sharer {
    private final static DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	
	// Sharer 类锁
    synchronized
    public static void printA() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

    // Sharer 对象锁
    synchronized
    public void printB() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

    // Sharer 对象锁
    public void printC() {
        synchronized (this) {
            System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        }
    }
}

程序运行结果

2019-10-15 11:21:01 线程=[ThreadB]进入 printB 方法
2019-10-15 11:21:01 线程=[ThreadA]进入 printA 方法
2019-10-15 11:21:03 线程=[ThreadB]离开 printB 方法
2019-10-15 11:21:03 线程=[ThreadC]进入 printC 方法
2019-10-15 11:21:03 线程=[ThreadA]离开 printA 方法
2019-10-15 11:21:05 线程=[ThreadC]离开 printC 方法

结论

public synchronized void myFun() {
	// ...
}
// 等价于
public void myFun() {
	synchronized (this) {
		// ...
	}
}

由程序运行结果输出得： printA、printB 方法同时执行， 可知 printB 和 printC 共用一个锁， 即 Sharer 对象锁

 

synchronized 类锁和多对象锁

public class Sharer {
    private final static DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	// Object 可用其他对象, 如： Sharer 等 
    private final static Object OBJECT = new Object();

	// Sharer 类锁
    synchronized
    public static void printA() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 对象锁
    synchronized
    public void printB() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }
	
	// OBJECT 对象锁
    public void printC() {
        synchronized (OBJECT) {
            System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        }
    }
}

程序运行结果

2019-10-15 11:25:33 线程=[ThreadB]进入 printB 方法
2019-10-15 11:25:33 线程=[ThreadC]进入 printC 方法
2019-10-15 11:25:33 线程=[ThreadA]进入 printA 方法
2019-10-15 11:25:35 线程=[ThreadC]离开 printC 方法
2019-10-15 11:25:35 线程=[ThreadB]离开 printB 方法
2019-10-15 11:25:35 线程=[ThreadA]离开 printA 方法

结论

由程序运行结果输出得： printA、printB、printC 三个函数同时执行， 可知三个锁属于不同锁

 

不同对象实例共用类锁

public class AnswerApp {
    public static void main(String[] args) throws InterruptedException {
    	// ThreadA、ThreadB、ThreadC 传入参数为不同对象
        ThreadA threadA = new ThreadA(new Sharer());
        threadA.setName("ThreadA");
        ThreadB threadB = new ThreadB(new Sharer());
        threadB.setName("ThreadB");
        ThreadC threadC = new ThreadC(new Sharer());
        threadC.setName("ThreadC");

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

public class Sharer {
    private final static DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

	// Sharer 类锁
    synchronized
    public static void printA() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 类锁
    synchronized
    public static void printB() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 类锁
    public void printC() {
        synchronized (Sharer.class) {
            System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        }
    }
}

程序运行结果

2019-10-15 11:44:13 线程=[ThreadA]进入 printA 方法
2019-10-15 11:44:15 线程=[ThreadA]离开 printA 方法
2019-10-15 11:44:15 线程=[ThreadC]进入 printC 方法
2019-10-15 11:44:17 线程=[ThreadC]离开 printC 方法
2019-10-15 11:44:17 线程=[ThreadB]进入 printB 方法
2019-10-15 11:44:19 线程=[ThreadB]离开 printB 方法

结论

由程序运行结果输出得： 由于ThreadA、ThreadB、ThreadC 传入参数为不同对象实例， 可知不同对象实例共用一个类锁

不同对象实例不共用对象锁

public class Sharer {
    private final static DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	// Sharer 对象锁
    synchronized
    public void printA() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printA 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 对象锁
    synchronized
    public void printB() {
        System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printB 方法",
                LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
    }

	// Sharer 对象锁
    public void printC() {
        synchronized (this) {
            System.out.println(MessageFormat.format("{0} 线程=[{1}]进入 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(MessageFormat.format("{0} 线程=[{1}]离开 printC 方法",
                    LocalDateTime.now().format(DATE_FORMATTER), Thread.currentThread().getName()));
        }
    }
}

程序运行结果

2019-10-15 11:48:29 线程=[ThreadC]进入 printC 方法
2019-10-15 11:48:29 线程=[ThreadA]进入 printA 方法
2019-10-15 11:48:29 线程=[ThreadB]进入 printB 方法
2019-10-15 11:48:31 线程=[ThreadC]离开 printC 方法
2019-10-15 11:48:31 线程=[ThreadA]离开 printA 方法
2019-10-15 11:48:31 线程=[ThreadB]离开 printB 方法

结论

由程序运行结果输出得： 由于ThreadA、ThreadB、ThreadC 传入参数为不同对象实例， 可知 不同对象之间的 对象锁 互不影响

Jaemon
关注
专栏目录
android handler runnable使用实例(关键是内部run中停止)
03-12
android handler runnable使用实例(关键是内部run中停止)
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
Java多线程编程-（1）-线程安全和锁Synchronized概念
Java后端技术
09-15 1391
1进程与线程的概念（1）在传统的操作系统中，程序并不能独立运行，作为资源分配和独立运行的基本单位都是进程。在未配置 OS 的系统中，程序的执行方式是顺序执行，即必须在一个程序执行完后，才允许另一个程序执行；在多道程序环境下，则允许多个程序并发执行。程序的这两种执行方式间有着显著的不同。也正是程序并发执行时的这种特征，才导致了在操作系统中引入进程的概念。自从在 20 世纪 60 年代人们提出了进程的
Java多线程编程-(1)-线程安全和锁Synchronized概念
JouZheYang的博客
03-22 305
一、进程和线程1、在传统的操作系统中，程序并不能独立运行，作为资源分配和独立运行的基本单位都是进程。2、进程是爹妈，管着众多线程儿子。3、进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。4、线程：有时被称为轻量级进程，lwp,是程序...
androidrunnable使用_android中Runnable的用法？
weixin_39904522的博客
12-22 481
展开全部只要java好就没有问题，这是3D魔方android的源码。package com.example.android.image3D;import android.view.SurfaceView;import android.view.SurfaceHolder;import android.content.Context;import android.util.AttributeSet;...
androidrunnable使用_Android 之神奇的 Runnable 对象
weixin_39533361的博客
12-22 942
回顾一下我们之前的 开启一个线程Thread并用进度条显示进度 小节，提到了这么一个东西：不允许在 WorkerThread 中去修改 UI，要修改 UI 只能通过在 WorkerThread 中用 Handler 将数据发送到消息队列中，然后在主线程用 Looper(就是在主线程中实例化 Handler) 将数据从消息队列中取出，才能修改 UI。那么，我们现在再来看看这么一个例子，会颠覆之前的看...
java多线程编程之使用Synchronized关键字同步类方法
09-04
在Java多线程编程中，`synchronized`关键字是一个至关重要的工具，用于处理并发访问时可能出现的数据一致性问题，也就是防止“脏数据”问题。当多个线程试图访问和修改同一块共享资源时，如果不加控制，可能会导致...
Java多线程-线程的安全问题与线程的同步机制介绍
最新发布
01-29
Java多线程-线程的安全问题与线程的同步机制介绍 在 Java 多线程编程中，线程安全问题是非常重要的一个话题。当多个线程访问同一个资源时，如果只有读操作那么不会出现线程安全问题，但是如果多个线程对资源进行读...
java多线程之线程,进程和Synchronized概念初解
08-28
总之，Java多线程通过线程和进程的概念提供了并发执行的能力，通过`synchronized`关键字确保了线程安全，避免了并发环境下的数据竞争。理解和熟练运用这些概念和机制对于编写高效、可靠的多线程Java应用程序至关重要...
Java多线程-多线程相关概念
01-19
Java多线程技术是编程中不可或缺的一部分，它允许程序在同一时间执行多个任务，从而提高效率和响应速度。本文将深入探讨多线程相关的概念。 首先，我们要了解程序、进程和线程的区别。程序是一组指令的集合，静态...
android demo，Runnable异步线程的处理
12-09
android demo，Runnable异步线程的处理
Android中实现Runnable接口简单例子
01-05
本课讲的是如何实现一个Runnable,在一个独立线程上运行Runnable.run()方法.Runnable对象执行特别操作有时叫作任务。 Thread和Runnable都是基础的类，靠他们自己，能力有限。作为替代，Android有强大的基础类，像HandlerThread，AsyncTask，IntentService。Thread和Runnable也是ThreadPoolExecutor的基础类。这个类可以自动管理线程和任务队列，甚至可以并行执行多线程。 定义一个实现Runnable接口的类 代码如下: public class PhotoDecodeRunnable implemen
线程安全和锁 Synchronized 概念
qq_42969887的博客
11-23 228
线程安全和锁 Synchronized 概念 进程（Process） 计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 线程 有时被称为轻量级进程（Lightweight Pro...
androidrunnable使用_安卓Runnable接口解释
weixin_39562606的博客
12-22 513
本人才疏学浅，如有错误之处，还请见谅Runnable接口解释官方地址如下:官方解释如下The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no argum...
android开发之多线程编程Thread和Runnable使用
chm880910的专栏
04-14 493
Android有两种方式实现多线程，一种是继承Thread类，覆写run()方法。一种是实现Runnable接口，再用该实现创建Thread。第一种方式：Java中一个类只能继承一个父类，该方式的局限性所在。package com.vixtel.tools; public class SyncThread extends Thread { @Override ...
android实现runnable接口,013 Android多线程-实现Runnable接口
weixin_34395361的博客
06-01 648
目录image1. 简介image2. 使用讲解2.1 使用步骤image特别注意：Java中真正能创建新线程的只有Thread类对象通过实现Runnable的方式，最终还是通过Thread类对象来创建线程所以对于 实现了Runnable接口的类，称为 线程辅助类；Thread类才是真正的线程类2.2 具体使用// 步骤1：创建线程辅助类，实现Runnable接口class MyThread im...
Android Runnable 用法
yuanlanxiaup
06-30 969
从Runnable派生你的子类，重载run()方法。 然后调用View.post(myRunnableObj)即可把你的Runnable对象增加到UI线程中运行。 boolean android.view.View .post(Runnable action) Causes the Runnable to be added to the message queue. T...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jaemon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值