synchronized同步代码块锁释放

今天发现自己写的线上程序出现数据库不能同步的问题,查看日志已经停止记录,随后使用jstack查看线程的运行状况,发现有个同步线程锁住了。

以下是jstack -l 637  问题线程的内容。

"schedulerJob-t-291" #314 daemon prio=5 os_prio=0 tid=0x00007f7d64844800 nid=0x3d5 runnable [0x00007f7d3a107000]
   java.lang.Thread.State: RUNNABLE
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at com.mysql.cj.core.io.ReadAheadInputStream.fill(ReadAheadInputStream.java:101)
	at com.mysql.cj.core.io.ReadAheadInputStream.readFromUnderlyingStreamIfNecessary(ReadAheadInputStream.java:144)
	at com.mysql.cj.core.io.ReadAheadInputStream.read(ReadAheadInputStream.java:174)
	- locked <0x00000000f13c2050> (a com.mysql.cj.core.io.ReadAheadInputStream)
	at java.io.FilterInputStream.read(FilterInputStream.java:133)
	at com.mysql.cj.core.io.FullReadInputStream.readFully(FullReadInputStream.java:58)
	at com.mysql.cj.mysqla.io.SimplePacketReader.readHeader(SimplePacketReader.java:60)
     ..........
	at org.springframework.data.repository.core.support.SurroundingTransactionDetectorMethodInterceptor.invoke(SurroundingTransactionDetectorMethodInterceptor.java:61)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185)
	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212)
	at com.sun.proxy.$Proxy91.saveAll(Unknown Source)
	at com.chenerzhu.crawler.proxy.pool.service.impl.ProxyIpServiceImpl.saveAll(ProxyIpServiceImpl.java:51)
	at com.chenerzhu.crawler.proxy.pool.job.scheduler.SyncDbSchedulerJob$1.call(SyncDbSchedulerJob.java:95)
	- locked <0x00000000f0745c78> (a java.lang.Class for com.chenerzhu.crawler.proxy.pool.job.scheduler.SyncDbSchedulerJob)
	at com.chenerzhu.crawler.proxy.pool.job.scheduler.SyncDbSchedulerJob$1.call(SyncDbSchedulerJob.java:55)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:
	- <0x00000000f1cb9350> (a java.util.concurrent.ThreadPoolExecutor$Worker)

查看代码发现代码中有这么一段

FutureTask task = new FutureTask(new Callable<ProxyIp>() {
                        @Override
      public ProxyIp call() {
         ......
          synchronized (SyncDbSchedulerJob.class){
              proxyIpService.saveAll(availableIpList);
              availableIpList.clear();
         }
        ........
      }
}

........

try {
            ProxyIp proxyIp = proxyIpFuture.get(10, TimeUnit.MINUTES);
            if(proxyIp!=null){
                    proxyIpList.add(proxyIp);
             }
     } catch (InterruptedException e) {
       log.error("Interrupted ", e);
    } catch (Exception e) {
       log.error("error:", e);
}

FutureTask中的synchronized批量保存数据,而Future获取使用了超时限制10分钟,由于数据量过大,同步时间超出10分钟了,停止了执行,而synchronized还未释放锁。导致线程锁住了。

最后通过减少每一次批量执行的数据到1000条,成功使synchronized代码块执行完释放锁。

===================================================================

总结下使用synchronized同步锁释放的时机。我们知道程序执行进入同步代码块中monitorenter代表尝试获取锁,退出代码块monitorexit代表释放锁。而在程序中,是无法显式释放对同步监视器的锁的,而会在如下4种情况下释放锁。

1、当前线程的同步方法、代码块执行结束的时候释放

2、当前线程在同步方法、同步代码块中遇到break 、 return 终于该代码块或者方法的时候释放。

3、出现未处理的error或者exception导致异常结束的时候释放

4、程序执行了 同步对象 wait 方法 ,当前线程暂停,释放锁

在以下两种情况不会释放锁。

1、代码块中使用了 Thread.sleep()  Thread.yield() 这些方法暂停线程的执行,不会释放。

2、线程执行同步代码块时,其他线程调用 suspend 方法将该线程挂起,该线程不会释放锁 ,所以我们应该避免使用 suspend 和 resume 来控制线程 。

原文地址:https://www.cnblogs.com/chenerzhu/p/9690119.html

时间: 2024-10-13 14:07:02

synchronized同步代码块锁释放的相关文章

java中多线程模拟(多生产,多消费,Lock实现同步锁,替代synchronized同步代码块)

import java.util.concurrent.locks.*; class DuckMsg{ int size;//烤鸭的大小 String id;//烤鸭的厂家和标号 DuckMsg(){ } DuckMsg(int size, String id){ this.size=size; this.id=id; } public String toString(){ return id + " 大小为:" + size; } } class Duck{ private int

java:synchronized 同步代码块

synchronized:利用上锁实现数据同步,避免多线程操作的情况下,数据出现异常. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行. 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 在代码块前加上 synchronized关键字,则此代码块就成为同步代码块, 格式: synchronized(同步对象){ 需要同步的代码: } class MyThread implements Runnab

Java---13---多线程:解决多线程的安全问题---synchronized 同步代码块

还是之前卖票的例子: class Test implements Runnable { private int num = 50; Object obj = new Object(); public void run () { while (true) { if (num >= 0) { try { Thread.sleep(20); } catch (Exception e) { // TODO: handle exception System.out.println(e.toString()

JAVA高并发程序设计学习:Synchronized同步代码块具体使用方法

多线程同时对资源进行访问时,同步机制使得同一时间内只能有一个线程对资源进行操作. 同步机制可以用Synchronized实现. 当Synchronized修饰一个方法的时候,该方法称为同步方法. 当Synchronized方法执行完成或者异常时会释放锁. 会有同学对synchronized修饰方法,静态方法,对象时具体对哪些东西加锁不是很明白,这里会进行详细的讲解. synchronized修饰方法时,会对类实例进行加锁,该实例的所有synchronized方法必须等当前锁释放后才能访问. sy

synchronized 同步代码块,售票问题

package cn.ljs.FristSync; public class SalerDemo extends Thread { static int tickets = 1000; String name; static Object lock = new Object(); public SalerDemo(String name) { this.name = name; } public void run(){ while(true){ synchronized (lock) { if

synchronized 与 ReentrantLock 同步代码块简单实现

synchronized 同步代码块: package net.flyingfat.lock; public class SyncLock { public static void main(String args[]){ final SyncLock lock=new SyncLock(); Thread.currentThread().setName("main"); new Thread(new Runnable() { public void run() { Thread.cu

java 多线程9 : synchronized锁机制 之 代码块锁

synchronized同步代码块 用关键字synchronized声明方法在某些情况下是有弊端的,比如A线程调用同步方法执行一个较长时间的任务,那么B线程必须等待比较长的时间.这种情况下可以尝试使用synchronized同步语句块来解决问题.看一下例子: 下面例子是优化后的例子 使用代码块锁,原先例子是方法锁,就是同步 必须要执行2个for  public class ThreadDomain18 { public void doLongTimeTask() throws Exception

java多线程(三)——锁机制synchronized(同步语句块)

用关键字synchronized声明方法在某些情况下是有弊端的,比如A线程调用同步方法之行一个长时间的任务,那么B线程必须等待比较长的时间,在这样的情况下可以使用synchronized同步语句快来解决. 一.用同步代码块解决同步方法的弊端 Task类 1 package com.weishiyao.learn.day4.testSynchorized.ep2; 2 3 public class Task { 4 5 private String getData1; 6 private Stri

synchronized锁机制 之 代码块锁(转)

synchronized同步代码块 用关键字synchronized声明方法在某些情况下是有弊端的,比如A线程调用同步方法执行一个较长时间的任务,那么B线程必须等待比较长的时间.这种情况下可以尝试使用synchronized同步语句块来解决问题.看一下例子: 下面例子是优化后的例子使用代码块锁,原先例子是方法锁,就是同步必须要执行2个for. public class ThreadDomain18 { public void doLongTimeTask() throws Exception {