20180925

一.Bug---企图修改公用静态成员变量

有那么一天随手写了一个简单的Result想用于前后端交互

public class TestResult {
    private  String code;
    private  String value;
    private  String data;
    public TestResult(TestEnum testEnum) {
        this.code = testEnum.getCode();
        this.value = testEnum.getValue();
        this.data = null;
    }
    public static final TestResult SUCESS=new TestResult(TestEnum.SUCESS);
    public static final TestResult FAIL=new TestResult(TestEnum.FAILE);
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
}

正常的情况下他是这样的

 

public static void main(String[] args) throws  Exception{

    TestResult result_sucess=TestResult.SUCESS;

    result_sucess.setData("返回成功");

    TestResult result_fail=TestResult.FAIL;

    result_fail.setData("返回失败");

    System.out.println("result_sucess"+JSONUtils.writeValueAsString(result_sucess));

    System.out.println("result_fail"+JSONUtils.writeValueAsString(result_fail));

}

result_sucess{"code":"200","value":"成功","data":"返回成功"}

result_fail{"code":"500","value":"失败","data":"返回失败"}

而有的时候是这样的

 

public static void main(String[] args) throws  Exception{

    TestResult result_1=TestResult.SUCESS;

    result_1.setData("返回成功---1");

    TestResult result_2=TestResult.SUCESS;

    result_2.setData("返回成功---2");

    System.out.println("result_1"+JSONUtils.writeValueAsString(result_1));

    System.out.println("result_2"+JSONUtils.writeValueAsString(result_2));

}

result_1{"code":"200","value":"成功","data":"返回成功---2"}

result_2{"code":"200","value":"成功","data":"返回成功---2"}

反应到页面上会发现并发请求返回的结果都是串的，很有喜感。。。。。。

才发现自己居然在企图修改公用静态成员的属性值，既想省事只加载一次，又想让他视情况而变化适应所有请求，可能是太贪心引起的bug吧。。。。

二.实现一个最简单的分布式锁

在数据库里随便存一个键值对，每次访问临界资源时先触发一个for update 的select操作,在唯一索引上使用唯一的查询条件（否则可能会导致数据库加间隙锁，导致并发性能下降），使mysql开启记录锁，获取到锁的线程获取执行权

1.数据库

CREATE TABLE `test_l` (

`lockName` varchar(20) NOT NULL,

`desc` varchar(100) DEFAULT NULL,

PRIMARY KEY (`lockName`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.分布式锁实现

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.TimeUnit;
@Service
public class LockServiceImpl implements LockService {
    @Resource
    DataSource dataSource;

    public interface LockRelease{
        void release();
    }

    public LockRelease lock(String name) throws SQLException, InterruptedException {
        final Connection connection = dataSource.getConnection();
        connection.setAutoCommit(false);
        int count =0;
        boolean success = false;
        while (count<4) {
            try {
                PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM test_l WHERE lockName = ? for update; ");
                preparedStatement.setString(1,name);
                preparedStatement.executeQuery();
                success = true;
                break;
            }catch (Exception e){
            }
            TimeUnit.MILLISECONDS.sleep(100);
            count++;
        }

        if(!success){
            logger.error("获取锁超时");
            throw new Exception("fail!");
        }

        return new LockRelease(){
            @Override
            public void release() {
                try {
                    connection.commit();
                    connection.close();
                } catch (SQLException e) {
                }
            }
        };
    }

}

2.使用测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.sql.SQLException;

@Service
public class TestService {
    @Autowired
    private LockService lockService;
/**
 *有锁测试
 */
    public void lockService(int i) throws SQLException, InterruptedException {
        LockServiceImpl.LockRelease lock = null;
        try {
                lock = lockService.lock("test_1");
            System.out.println(i+"执行开始");
            Thread.sleep(1000);
            System.out.println(i+"执行结束");
        } finally {
            if (null != lock) {
                lock.release() ;
            }
        }
    }
/**
 *无锁测试
 */
    public void unLockService(int i) throws InterruptedException {
        System.out.println(i + "执行开始");
        Thread.sleep(1000);
        System.out.println(i + "执行结束");
    }
}

 3，起一个线程池进行测试

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Controller
@RequestMapping("/syn")
public class TestController {
    @Resource
    TestService testService;
     private static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 12, 30,
            TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), new ThreadPoolExecutor.AbortPolicy());
    @RequestMapping("unLockTest")
    @ResponseBody
    public Object unLockTest() throws InterruptedException {
        List<Callable<Integer>> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(taskUnLock(i));
        }
        threadPool.invokeAll(list);
         return "unlock ok!";
    }
    @RequestMapping("lockTest")
    @ResponseBody
    public Object lockTest() throws InterruptedException {
        List<Callable<Integer>> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(taskLock(i));
        }
        threadPool.invokeAll(list);
        return "lock ok!";
    }
    public  Callable<Integer> taskUnLock(final Integer i){
        return new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                testService.unLockService(i);
                return i;
            }
        };
    }
   public  Callable<Integer> taskLock( final Integer i){
        return new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                testService.lockService(i);
                return i;
            }
        };
    }
}

 

4.有锁测试结果

 

 

5.无锁测试结果

三.发现几个好用的idea插件

1.ideaVim

直接在file-setting-plugin中搜索vim进行安装即可，熟练使用vim指令后可以基本解除鼠标操作，极大提高编码效率

2.Alibaba p3c

非常好用的代码规范插件

鼠标放到曲线代码下就能提示不规范信息，养成编码好习惯。。。。

3.find-bugs

一个代码纠错的插件，认为最有用的是他可以找出代码中未处理的空指针异常，提交代码前find-bugs一下很方便

 

四.一个好用的时间，日期处理工具 Joda Time

这篇文章讲的很详细 https://www.jianshu.com/p/797716dc49fb

五@Resource和@Autowired

两者都是用做bean注入时使用的，@Resource由J2EE提供，@Autowired由spring提供

@Autowired默认通过byType装配依赖对象，@Resource默认则默认通过byName装配依赖对象

所以在注入远程调用的服务时如果使用@Resource进行注入会报错

Error creating bean with name '***': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanNotOfRequiredTypeException

改为@Autowired后即可正常运行