解决并发问题

曾经终败给现在 2022-06-05 04:36 251阅读 0赞

总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

2）Lock和synchronized有一点非常大的不同，采用 synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放 对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

2.ReentrantLock

ReentrantLock，意思是“可重入锁”，关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

`Lock lock = ``new` `ReentrantLock();   `

`lock.lock();`

```lock.unlock();`

3.ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

4.ReentrantReadWriteLock

ReadWriteLock接口，ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

ReadWriteLock lock = new ReentrantReadWriteLock();

Lock writeLock = lock.writeLock();    
writeLock.lock();

writeLock.unlock();

Lock readLock = lock.readLock();    
readLock.lock();

readLock.unlock();

5.Lock和synchronized的选择

总结来说，Lock和synchronized有以下几点不同：

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

package com.yanshu.controller;  
  
  
import java.net.InetAddress;  
import java.net.UnknownHostException;  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.LinkedList;  
import java.util.List;  
import java.util.Map;  
import java.util.PriorityQueue;  
import java.util.Queue;  
import java.util.Set;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReadWriteLock;  
import java.util.concurrent.locks.ReentrantLock;  
import java.util.concurrent.locks.ReentrantReadWriteLock;  
  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.CrossOrigin;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.RestController;  
  
  
import com.alibaba.fastjson.JSON;  
import com.yanshu.dao.CategoryLeafKeywordsDao;  
import com.yanshu.dao.LogkeywordsDao;  
import com.yanshu.pojo.CategoryLeafKeywords;  
import com.yanshu.pojo.ComtyinfoDistinct;  
import com.yanshu.pojo.LcsyGoodsinfodistinct;  
import com.yanshu.pojo.Logkeywords;  
import com.yanshu.pojo.OpenCate;  
import com.yanshu.utils.DigitUtils;  
import com.yanshu.utils.JsonUtil;  
import com.yanshu.utils.MessageUtils;  
import com.yanshu.utils.StringUtils;  
import java.util.Map.Entry;  
/\*\*  
 \* 类别叶关键词  
 \* @author Administrator  
 \*叶子类目关键词索引表  
 \*/  
@RestController  
@CrossOrigin  
public class CategoryLeafController \{  
@Autowired  
private CategoryLeafKeywordsDao clkdao;  
  
@Autowired  
private LogkeywordsDao logdao;  
List<Map<String,Object>> ltcids=new ArrayList<>();  
Map<String,Object> mcids=new HashMap<>();  
public CategoryLeafController() \{  
// TODO Auto-generated constructor stub  
\}  
//private static final Queue<CategoryLeafKeywords> queueAll = new LinkedList<>();  
private static final PriorityQueue<CategoryLeafKeywords> queueAll = new PriorityQueue<CategoryLeafKeywords>();  
  
public static PriorityQueue<CategoryLeafKeywords> getInstance() \{     
return  queueAll;    
 \}  
private static final SimpleDateFormat dateFormat1 = new SimpleDateFormat("yyyyMMdd");  
// 锁    
    ReadWriteLock lock = new ReentrantReadWriteLock();   
    Lock readLock = lock.readLock();    
/\*\*  
\* http://localhost:8080/spiderQue/getkey?num=100  
\* http://211.95.60.40:16868/spiderQue/getkey?num=100  
\* @return   
\*/  
@RequestMapping(value="/getkey", method = \{ RequestMethod.GET,RequestMethod.POST \}, produces = "application/json; charset=utf-8")  
public synchronized String getCategoryLeafKeywords(String num)  
\{  
// 得到readLock并锁定    
      //  readLock.lock();    
try\{  
List<CategoryLeafKeywords> returnUsers;  
Integer incount;  
if(StringUtils.isNullorEmpty(num))  
\{  
return JsonUtil.errorMessages(1);  
\}  
else  
\{  
  
String strtime=dateFormat1.format(new Date());  
Map map=new HashMap();  
map.put("operationTime", strtime);   
//获取的时间  
//查询到最大的时间  
List<Logkeywords> loglist=logdao.findByLogkeywords(map);  
//获得数据---从数据  
boolean result = false;  
       for(String key:mcids.keySet())\{  
         if(strtime.equals(mcids.get(key)))\{  
               result=true;  
               break;  
           \}  
       \}  
if(loglist.size()<1)  
\{  
//根据用户传递的ID 查询，把数据存到队列里面去  
List<CategoryLeafKeywords> findcakw=clkdao.findBykeyword();  
for (CategoryLeafKeywords object : findcakw) \{  
queueAll.offer(object);  
\}  
clkdao.updateKeywordsAll();  
//保存当前,日期和，用户传递的ID到日志表  
logdao.save(map);  
mcids.put(strtime, strtime);  
\}  
//从队列里面拿数据  
returnUsers= new ArrayList<>();  
incount = Integer.parseInt(num);   
for (int i = 1; i<=incount; i++) \{  
if(queueAll.size()>1)\{  
returnUsers.add(queueAll.poll());  
\}  
\}  
//System.out.println("队列为了==="+queueAll.size());  
    /\*   if(queueAll.size()<=0)  
       \{  //System.out.println("队列走==="+queueAll.size());  
        //根据用户传递的ID 查询，把数据存到队列里面去  
List<CategoryLeafKeywords> findcakw=clkdao.findBykeyword();  
for (CategoryLeafKeywords object : findcakw) \{  
queueAll.offer(object);  
\}  
clkdao.updateKeywordsAll();  
//从队列里面拿数据  
returnUsers= new ArrayList<>();  
incount = Integer.parseInt(num);   
for (int i = 1; i<=incount; i++) \{  
if(queueAll.size()>1)\{  
returnUsers.add(queueAll.poll());  
\}  
\}  
       \}\*/   
return returnUsers.size()!=0?JSON.toJSONString(returnUsers):JsonUtil.errorMessages(8);  
\}  
\}  
finally  
\{  
// 释放readLock    
            readLock.unlock();    
\}  
  
\}  
@RequestMapping("/fkdqcount")  
public int getQueueSelect()  
\{  
int size = queueAll.size();  
if(size==1)  
\{  
return 0;  
\}  
else  
\{  
return size;  
\}  
\}  
@RequestMapping("/fkdqClear")  
public String getClearQueue()  
\{  
queueAll.clear();  
return JSON.toJSONString("该队列已经清空!!!");  
\}  
/\*\*  
\* http://localhost:8080/spiderQue/upKeywords?cdid=1,2,3,4,5   
\* @param cdid  
\* @return  
\*/  
@RequestMapping(value="/upKeywords", method = \{ RequestMethod.GET,RequestMethod.POST \}, produces = "application/json; charset=utf-8")  
public String updateDate(String cdid)  
\{  
  
if(StringUtils.isNullorEmpty(cdid))  
\{  
return MessageUtils.errorMessages(1);  
\}else  
\{  
  
int size = 0;  
Map<String,Object> mapsussuccess=new HashMap<String,Object>();  
List listnum=new ArrayList();  
//String cdids="16384,16385,16386,16387,16388,16392,16393,16394,";  
//String substring = cdid.substring(0, cdid.length()-1);  
String\[\] split = cdid.split(",");  
  
int length = split.length;  
//Map map=new HashMap();  
//map.put("cdid", cdid);  
try \{  
int count=0;  
for(int i=0;i<length;i++)  
\{  
String string = split\[i\];  
//System.out.println(string);  
for(int j=0;j<string.length();j++)  
\{//List<CategoryLeafKeywords> findBykeywordId(String ckid);  
//List<ComtyinfoDistinct> findByComtyinfoid(String cdid);  
List<CategoryLeafKeywords> findByGoodsinfoselectID = clkdao.findBykeywordId(string);  
Integer status = findByGoodsinfoselectID.get(j).getSpdier\_status();  
Integer id = findByGoodsinfoselectID.get(j).getId();  
//System.out.println("status--->"+status);  
  
if(status.equals(0)||status==0)  
\{  
listnum.add(id);  
size = listnum.size();  
//System.out.println("listnum==>"+listnum);  
//System.out.println("listnum==>"+size);  
for(int z=0;z<size;z++)  
\{  
Object object = listnum.get(z);  
//lcygdao.update(object);  
//cdao.updateDate(object);  
clkdao.updateKeywords(object);  
\}  
  
\}  
\}  
  
//Integer status = findByGoodsinfoselectID.get(i).getStatus();  
//System.out.println("status==>"+status);  
//  
\}  
\} catch (Exception e) \{  
// TODO Auto-generated catch block  
return MessageUtils.errorMessages(1);  
\}  
//cdao.updateDate(map);  
mapsussuccess.put("linage", size);  
mapsussuccess.put("code", 200);  
mapsussuccess.put("message", "Congratulations, you made it!!!");  
return JSON.toJSONString(mapsussuccess);  
  
  
  
\}  
  
  
\}  
@RequestMapping("/gp")  
public String getIp() throws UnknownHostException  
\{  
 InetAddress addr = InetAddress.getLocalHost();  
     System.out.println("Local HostAddress: "+addr.getHostAddress());  
     String hostname = addr.getHostName();  
     System.out.println("Local host name: "+hostname);  
     return addr.getHostAddress();  
\}  
  
  
\}