Java:使用synchronized和Lock对象获取对象锁

dw_java08 dw_java08 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 500+累计阅读 594平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄15年
关注
转载 最新推荐文章于 2026-07-05 10:40:32 发布 594 阅读 AI 写同款· GEO 优化 ›
服务器安全升级：ssl证书配置好，设置http跳转https的几种方法 怎么设置http跳转到https？在为网站部署SSL证书后，可以实现https加密访问，但是网站的用户往往习惯了http访问，这个时候我们就需要设置访问http时自动跳转到https。下面收集了几种常见的服务器环境下设置http跳转到https方法，供大家参考： 1、Apache设置http跳转到https （1）Apache环境下实现整站http自动跳转到https需在网站的配置文件 阅读详情
原创作品，允许转载，转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 http://zhangjunhd.blog.51cto.com/113473/70300
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
1.对象的锁
所有对象都自动含有单一的锁。
JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。
只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。
每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。
2.synchronized同步块
2.1同步到单一对象锁
当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象  synchronized  ( this )），所以对它们的方法依然是互斥的。
Resource1.java
package  com.zj.lock;
import  java.util.concurrent.TimeUnit;
 
public   class  Resource1 {
     public   void  f() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in f()" );
        synchronized  ( this ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in f()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   void  g() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in g()" );
        synchronized  ( this ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in g()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   void  h() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in h()" );
        synchronized  ( this ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in h()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   static   void  main(String[] args) {
        final  Resource1 rs =  new  Resource1();
 
        new  Thread() {
            public   void  run() {
              rs.f();
           }
       }.start();
 
        new  Thread() {
            public   void  run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
2.2 同步到多个对象锁
Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（ synchronized  ( this ) ， synchronized ( syncObject1 ) ， synchronized  ( syncObject2 )），所以对它们的方法中的临界资源访问是独立的。
Resource2.java
package  com.zj.lock;
import  java.util.concurrent.TimeUnit;
 
public   class  Resource2 {
     private  Object  syncObject1  =  new  Object();
     private  Object  syncObject2  =  new  Object();
 
     public   void  f() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in f()" );
        synchronized  ( this ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in f()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   void  g() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in g()" );
        synchronized  ( syncObject1 ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in g()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   void  h() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in h()" );
        synchronized  ( syncObject2 ) {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in h()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
     public   static   void  main(String[] args) {
        final  Resource2 rs =  new  Resource2();
 
        new  Thread() {
            public   void  run() {
              rs.f();
           }
       }.start();
 
        new  Thread() {
            public   void  run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
3.Lock对象锁
除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。
Resource3.java
package  com.zj.lock;
import  java.util.concurrent.TimeUnit;
import  java.util.concurrent.locks.Lock;
import  java.util.concurrent.locks.ReentrantLock;
 
public   class  Resource3 {
     private  Lock  lock  =  new  ReentrantLock();
 
     public   void  f() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in f()" );
        lock .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in f()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock .unlock();
       }
    }
 
     public   void  g() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in g()" );
        lock .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in g()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock .unlock();
       }
    }
 
     public   void  h() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in h()" );
        lock .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in h()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock .unlock();
       }
    }
 
     public   static   void  main(String[] args) {
        final  Resource3 rs =  new  Resource3();
 
        new  Thread() {
            public   void  run() {
              rs.f();
           }
       }.start();
 
        new  Thread() {
            public   void  run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Resource4.java
package  com.zj.lock;
import  java.util.concurrent.TimeUnit;
import  java.util.concurrent.locks.Lock;
import  java.util.concurrent.locks.ReentrantLock;
 
public   class  Resource4 {
     private  Lock  lock1  =  new  ReentrantLock();
     private  Lock  lock2  =  new  ReentrantLock();
     private  Lock  lock3  =  new  ReentrantLock();
 
     public   void  f() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in f()" );
        lock1 .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in f()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock1 .unlock();
       }
    }
 
     public   void  g() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in g()" );
        lock2 .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in g()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock2 .unlock();
       }
    }
 
     public   void  h() {
        // other operations should not be locked...
       System. out .println(Thread.currentThread().getName()
              +  ":not synchronized in h()" );
        lock3 .lock();
        try  {
            for  ( int  i = 0; i < 5; i++) {
              System. out .println(Thread.currentThread().getName()
                     +  ":synchronized in h()" );
               try  {
                  TimeUnit. SECONDS .sleep(3);
              }  catch  (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }  finally  {
            lock3 .unlock();
       }
    }
 
     public   static   void  main(String[] args) {
        final  Resource4 rs =  new  Resource4();
 
        new  Thread() {
            public   void  run() {
              rs.f();
           }
       }.start();
 
        new  Thread() {
            public   void  run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()

本文出自 “子 孑” 博客，请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/70300

标签
#java #任务 #string #jvm
Tomcat 8.5 从零部署到生产环境配置全指南 Servlet容器是Java Web应用运行的核心环境，它负责处理HTTP请求、管理Servlet生命周期并提供会话管理等基础服务。其工作原理基于Java EE规范，通过接收请求、调用对应的Servlet并返回响应来实现动态网页的生成。这项技术的价值在于为Java Web开发提供了标准化、可移植的运行时环境，极大简化了服务器端程序的部署与管理。在实际应用场景中，无论是传统的企业级应用、教学演示还是遗留系统维护，一个稳定且配置得当的Servlet容器都至关重要。本文将聚焦于Apache Tomcat 8.5这 阅读详情

相关推荐

你刚才提到获取对象的锁，这个“锁”到底是什么？如何确定对象的锁？

锁”的本质其实是 monitorenter 和 monitorexit 字节码指令的一个 Reference 类型的参数，即要锁定和解锁的对象。我们知道，使用 Synchronized 可以修饰不同的对象，因此，对应的对象锁可以这么确定。 1. 如果 Synchronized 明确指定了锁对象，比如 Synchronized（变量名）、Synchronized(this) 等，说明加解锁对象为该对象。 2. 如果没有明确指定： 若 Synchronized 修饰的方法为非静态方法，表示此方法对应的对象为

qq_62205007的博客 867

【Java多线程】-读写锁ReadWriteLock

大家可能遇到这样的情况：在读写共享数据时，要求写入与写入互斥，读取与写入互斥，而读取和读取不要求互斥。我相信大家都知道需要加锁来实现互斥，但是普通的锁能达到我么的要求吗？我们来看看下面的代码：package org.iti.thread;import java.util.Random;public class ThreadReadWriteLock { public static void

小飞飞的专栏 668

java 类锁如何获得_Java Synchronized获得类的锁和获得对象的锁有什么区别呢？

对象锁&类锁对象锁当一个对象中有synchronized method或synchronized block的时候调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放同步静态方法/静态变量互斥体由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只由一份。所以，一旦一个静态的方法被申明为synchroni...

weixin_32655655的博客 254

Java Lock同步锁

Lock同步锁 Lock是一个接口，用来手动的获取和释放锁，具体源码为 public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit un...

欧尔麦特 850

部署https(ssl证书)设置301跳转，将http跳转到https的方法

注意，以下教程针对SSL虚拟主机部署SSL后的301跳转 linux操作系统 apache环境 云服务器：【直接在apache上部署的SSL】在对应站点根目录下新建（通过ftp或登录wdcp管理面板中：站点列表-文管-进入public_html-创建文件）一个文件命名为.htaccess。 1 2 3 4 5 6 7 8 ...

点滴分享博客 8367

部署https(ssl)后设置301跳转将http跳转到https

linux系统 apache环境 云服务器：【直接在apache上部署的SSL】在对应站点根目录下新建（通过ftp或登录wdcp管理面板中：站点列表-文管-进入public_html-创建文件）一个文件命名为.htaccess。 <IfModulemod_rewrite.c> RewriteEngineOn RewriteCond%{HTTPS}!^on$[NC]...

木头分享 - 分享有价值的、实用的干货 4494

301跳转 https_部署https(ssl)后设置301跳转将http跳转到https

注意，以下教程只针对我司港台虚拟主机或者亚数的云主机香港IP部署SSL后的301跳转linuxt系统 apache环境云服务器：在对应站点根目录下新建(通过ftp或登录wdcp管理面板中：站点列表-文管-进入public_html-创建文件)一个文件命名为.htaccess。虚拟主机：可以通过ftp或登录后进入到主机管理面板-文件管理,进入wwwroot,新建一个文件命名为.htaccess文件,...

weixin_39951929的博客 202

Tomcat部署项目、修改端口和了解

项目部署的方式 方式一 直接将项目放到tomcat文件夹下的webapps目录下即可 方式二 在tomcat文件夹下的conf/server.xml中配置，host标签中添加： <Context docBase="E:\Program\JspProject" path= "/JspProject" /> 然后重启tomcat docBase：实际路径 path：虚拟路径 (绝对路径、...

java知识整理 3331

http 自动跳转https_java项目https升级实战

一个很老的项目需要在生产中使用https,记录下！目标使用http访问网站自动跳转到https,代码中不强制使用https以便可以在开发测试环境方便使用。关键字 java,springmvc,shiro,tomcat,nginx.1，项目部署图升级后部署图2，需要的改动：nginx :在80端口的server 中 增加rewrite ^(.*)$ https://$server_name$1修改目...

weixin_36444104的博客 634

html发布 https,部署https(ssl证书)后设置301跳转将http跳转到https的方法 附本站规则...

linux操作系统 apache环境云服务器：【直接在apache上部署的SSL】在对应站点根目录下新建(通过ftp或登录wdcp管理面板中：站点列表-文管-进入public_html-创建文件)一个文件命名为.htaccess。RewriteEngineOnRewriteCond%{HTTP:From-Https}!^on$[NC]#RewriteCond%{HTTPS}!^on$...

weixin_33074843的博客 711

Linux系统nginx反向代理实现“https://”访问tomcat项目

目标：实现 “https://” 域名访问tomcat下的项目 环境：centos7（或者其他Linux系统版本） 软件：tomcat9 jdk1.8 nginx1.16 工具：Xftp6(FTP工具) Xshell6(SSH工具)。默认在windows客户端系统下使用，mac os系统另行下载其他ftp工具。 相关软件安装下载： Linux 安装JDK1.8环境 Linux 安装nginx L...

pdfh5.js的博客 754

java 部署tomcat_JavaWeb之Tomcat的安装和部署

Download Tomcat下载网址：https://tomcat.apache.org/一般选择比较新的版本(8.5)，最新的版本可能会不稳定，不适合开发，7.0及以下版本编码(ISO-8859-1)和8.0版本及以上(UTF-8)是不一样的。从上图可以看到，tomcat依赖于jdk,而且不同t版本的tomca对jdk有不同的版本要求例如，在安装tomcat8.5时需要先安装jdk7或以上，且...

weixin_36431157的博客 315

Javaweb学习之Tomcat

由 Apache 组织提供的一种 Web 服务器，提供对 jsp 和 Servlet 的支持。它是一种轻量级的 javaWeb 容器(服务器)，也是当前应用最广的 JavaWeb 服务器(免费)

weixin_45910629的博客 995

nginx代理php不能跳转页面,nginx 解决首页跳转问题详解

nginx和tomcat负载均衡比如 www.csdn.NET 网站后面有 2个tomcat。配置负载均衡：upstream csdn-tomcat{server 192.168.100.101:8080;server 192.168.100.102:8080;}server {listen 80;server_name www.csdn.net csdn.net;index index.html...

weixin_42514002的博客 1287

深入解析HTTP 301重定向与HSTS安全策略：从协议原理到实战配置

HTTP重定向是Web开发中的基础技术，它通过在服务器响应中返回特定的状态码，指示客户端自动跳转到新的URL。其核心原理在于HTTP协议的状态码与响应头机制，例如301状态码配合Location头实现永久重定向。这项技术的核心价值在于保障网站的可访问性、维护SEO权重，并作为实施HTTPS等安全策略的关键桥梁。在应用场景上，它广泛用于域名变更、HTTPS强制升级和URL结构优化。本文聚焦于301重定向与HSTS（HTTP严格传输安全）的深度结合，详细拆解了如何通过301重定向实现HTTP到HTTPS的无缝跳

aebe49167的博客 496

ssl部署——tomcat+nginx

申请ssl证书 可以在下面的网站申请ssl证书 https://freessl.cn/ 输入网址——创建证书 输入邮箱——选择证书类型RSA——认证方式DNS——游览器生成——点击创建 注:可以自行在服务器上使用openssl生成私钥和CSR文件,然后此处选择我有CSR文件即可.详细生成步骤自行百度. 根据提示在DNS服务商处,添加一条TXT解析.此处以阿里云为例. 将...

CN_SHzhaoyujie的博客 528

Tomcat URL重写实战：构建移动优先索引的SEO架构

你是否正面临这些困境？移动用户访问桌面版URL导致跳出率飙升30%以上？搜索引擎因重复内容而降权核心页面？服务器日志中充斥着404错误却找不到源头？本文将系统讲解如何通过Tomcat的URL重写机制实现移动优先索引，同时解决跨设备一致性、SEO权重集中和用户体验优化三大核心问题。 读完本文你将掌握： - Tomcat RewriteValve的底层工作原理与配置方法 - 移动设备识别与URL智能...

gitblog_00194的博客 843
上一篇： Eclipse中将Java项目 打包为jar,并且引入第三方jar包 解决办法
下一篇： 移位运算符学习
点赞 0
评论 0
书签 书签 1
dw_java08
dw_java08
博客等级 码龄15年 121粉丝 66原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值