研发之道
研发之道

关于事务、ThreadLocal应用、CompletionService的一些总结

一、ThreadLocal的本质：

Thread 类组合一个ThreadLocal.ThreadLocalMap 所以ThreadLocalMap 是ThreadLocal 的内部类， ThreadLocalMap 是ThreadLocal 自己实现的一个key、value map结构，初始化Entry 长度16、其中key 基于弱引用。key 是 一个ThreadLocal 实例。所以单纯的说ThreadLocal 的 key 为线程本身压根就是不贴切的。

   static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

看一下get 方法

其中getMap 就是拿到Thread 类实例中所组合的ThreadLocalMap ，getEntry 就是把线程所关联的ThreadLocal 类实例作为key 来搞数据。而value对应线程的变量副本，每个线程可能存在多个ThreadLocal

   public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

set方法 很简单

  public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

二 Spring的事务管理器如何玩儿的 ThreadLocal

以DataSourceTransactionManager 这个管理器为例。

protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction;
        Connection con = null;

        try {
            if(txObject.getConnectionHolder() == null || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = this.dataSource.getConnection();
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }

                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);
            if(con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }

                con.setAutoCommit(false);
            }

            txObject.getConnectionHolder().setTransactionActive(true);
            int timeout = this.determineTimeout(definition);
            if(timeout != -1) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }

            if(txObject.isNewConnectionHolder()) {
                TransactionSynchronizationManager.bindResource(this.getDataSource(), txObject.getConnectionHolder());
            }

        } catch (Throwable var7) {
            DataSourceUtils.releaseConnection(con, this.dataSource);
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);
        }
    }

这个Connection 就是我们常见的jdbc的连接， 主要是利用jdbc接口设置事务不自动提交 ，而有spring来控制何时提交、何时回滚。如果是新的连接创建， 那么bindResource 方法就把Connection 的holder 扔到ThreadLocalMap 里面了。 当线程间切换时，保证了连接资源的 一致性。

  public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Assert.notNull(value, "Value must not be null");
        Map<Object, Object> map = (Map)resources.get();
        if(map == null) {
            map = new HashMap();
            resources.set(map);
        }

        Object oldValue = ((Map)map).put(actualKey, value);
        if(oldValue instanceof ResourceHolder && ((ResourceHolder)oldValue).isVoid()) {
            oldValue = null;
        }

ThreadLocal可能存在的 内存泄漏问题

关于事务、ThreadLocal应用、CompletionService的一些总结_第1张图片
　 当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例,所以threadlocal将会被gc回收. 但是,我们的value却不能回收,因为存在一条从current thread连接过来的强引用. 只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收.

ThreadLocal在dubbo分布式调用跟踪中使用

在dubbo 中monitor 是一个单独的模块部署， 即使挂了也不耽误provider 和和consumer 继续暧昧。
在Dubbo的核心领域模型中：
1. Protocol是服务域，它是Invoker暴露和引用的主功能入口，它负责Invoker的生命周期管理。
2. Invoker是实体域，它是Dubbo的核心模型，其它模型都向它靠扰，或转换成它，它代表一个可执行体，可向它发起invoke调用，它有可能是一个本地的实现，也可能是一个远程的实现，也可能一个集群实现。
3. Invocation是会话域，它持有调用过程中的变量，比如方法名，参数等。
在dubbo-monitor-api 中：MonitorFilter 实现了Filter：

// 调用过程拦截
    public Result invoke(Invoker invoker, Invocation invocation) throws RpcException {
   //如果配置了监控中心
        if (invoker.getUrl().hasParameter(Constants.MONITOR_KEY)) {
            RpcContext context = RpcContext.getContext(); // 提供方必须在invoke()之前获取context信息
            long start = System.currentTimeMillis(); // 记录起始时间戮
            getConcurrent(invoker, invocation).incrementAndGet(); // 并发计数
            try {
                Result result = invoker.invoke(invocation); // 让调用链往下执行
                collect(invoker, invocation, result, context, start, false);
                return result;
            } catch (RpcException e) {
                collect(invoker, invocation, null, context, start, true);
                throw e;
            } finally {
                getConcurrent(invoker, invocation).decrementAndGet(); // 并发计数
            }
        } else { //没有配置监控中心
            return invoker.invoke(invocation);
        }
    }

看一下如何做的信息采集collect 方法： 主要逻辑是根据是服务提供方还是消费方获取监控采集参数， 并发送到监控中心。

 // 信息采集
    private void collect(Invoker invoker, Invocation invocation, Result result, RpcContext context, long start, boolean error) {
        try {
            // ---- 服务信息获取 ----
            long elapsed = System.currentTimeMillis() - start; // 计算调用耗时
            int concurrent = getConcurrent(invoker, invocation).get(); // 当前并发数
            String application = invoker.getUrl().getParameter(Constants.APPLICATION_KEY);
            String service = invoker.getInterface().getName(); // 获取服务名称
            String method = RpcUtils.getMethodName(invocation); // 获取方法名
            URL url = invoker.getUrl().getUrlParameter(Constants.MONITOR_KEY);
            Monitor monitor = monitorFactory.getMonitor(url);
            int localPort;
            String remoteKey;
            String remoteValue;
            if (Constants.CONSUMER_SIDE.equals(invoker.getUrl().getParameter(Constants.SIDE_KEY))) {
                // ---- 服务消费方监控 ----
                context = RpcContext.getContext(); // 消费方必须在invoke()之后获取context信息
                localPort = 0;
                remoteKey = MonitorService.PROVIDER;
                remoteValue = invoker.getUrl().getAddress();
            } else {
                // ---- 服务提供方监控 ----
                localPort = invoker.getUrl().getPort();
                remoteKey = MonitorService.CONSUMER;
                remoteValue = context.getRemoteHost();
            }
            String input = "", output = "";
            if (invocation.getAttachment(Constants.INPUT_KEY) != null) {
                input = invocation.getAttachment(Constants.INPUT_KEY);
            }
            if (result != null && result.getAttachment(Constants.OUTPUT_KEY) != null) {
                output = result.getAttachment(Constants.OUTPUT_KEY);
            }
            monitor.collect(new URL(Constants.COUNT_PROTOCOL,
                                NetUtils.getLocalHost(), localPort,
                                service + "/" + method,
                                MonitorService.APPLICATION, application,
                                MonitorService.INTERFACE, service,
                                MonitorService.METHOD, method,
                                remoteKey, remoteValue,
                                error ? MonitorService.FAILURE : MonitorService.SUCCESS, "1",
                                MonitorService.ELAPSED, String.valueOf(elapsed),
                                MonitorService.CONCURRENT, String.valueOf(concurrent),
                                Constants.INPUT_KEY, input,
                                Constants.OUTPUT_KEY, output));
        } catch (Throwable t) {
            logger.error("Failed to monitor count service " + invoker.getUrl() + ", cause: " + t.getMessage(), t);
        }
    }

重点在于：

   if (invocation.getAttachment(Constants.INPUT_KEY) != null) {
                input = invocation.getAttachment(Constants.INPUT_KEY);
            }
            if (result != null && result.getAttachment(Constants.OUTPUT_KEY) != null) {
                output = result.getAttachment(Constants.OUTPUT_KEY);
            }

分布式调用链想要串起来， 一般有一个类似于traceId 的东西 一直往下传。在并发下， dubbo如何确认到底哪一个调用方传过来的traceId ， 那就需要dubbo处理请求线程 去和traceId 绑定了。继而ThreadLocal 应运而生。其它分布式调用跟踪框架可以通过扩展dubbo 的Filter 并通过invocation 的attachment 来传递这些traceId、`

ThreadLocal在mybatis框架中的使用

SqlSession 声明周期内线程不共享

public class SqlSessionManager implements SqlSessionFactory, SqlSession {
  private final SqlSessionFactory sqlSessionFactory;
  // proxy
  private final SqlSession sqlSessionProxy;
  // 保持线程局部变量SqlSession的地方
  private ThreadLocal localSqlSession = new ThreadLocal();
  private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
    this.sqlSessionFactory = sqlSessionFactory;
    // 这个proxy是重点
    this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
        SqlSessionFactory.class.getClassLoader(),
        new Class[]{SqlSession.class},
        new SqlSessionInterceptor());
  }
  public static SqlSessionManager newInstance(Reader reader) {
    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, null));
  }
  public static SqlSessionManager newInstance(Reader reader, String environment) {
    return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, environment,
null));
  }
  //...
  // 设置线程局部变量sqlSession的方法
  public void startManagedSession() {
    this.localSqlSession.set(openSession());
  }
  public void startManagedSession(boolean autoCommit) {
    this.localSqlSession.set(openSession(autoCommit));
  }
  //...
  @Override
  public  T selectOne(String statement, Object parameter) {
    return sqlSessionProxy. selectOne(statement, parameter);
  }
  @Override
  public  Map selectMap(String statement, String mapKey) {
    return sqlSessionProxy. selectMap(statement, mapKey);
  }
  //..

ThreadLocal在SpringMvc中的使用

在FrameworkServlet.java 中 所有的doGet 、doPost。。。。全都委托给了processRequest 方法 统一处理。 processrequest 的核心语句是doService， 是一个模版方法， 在DispatcherServlet 有具体的实现。在doService 前后 我们看看分别干了什么有趣的事儿。在之前 首先获取了LocaleContextHodler 和 RequestContextHolder 中原来保存的LocaleContext 和RequestAttributes 并设置到previousLocaleContext 和 previousAttributes 临时属性， 然后调用buildLocaleContext 和 buildRequestAttributes 方法获取到当前请求的LocaleContext 和RequestAttributes ， 并通过initContextHolders 方法将它们设置到LocaleContextHolder 和 RequestContextHolder， 然后设置了拦截器， 接着调用了最重要的 doService 方法， finally 中， 通过resetContextHolders 方法将原来的previousAttributes 和 previousLocaleContext 恢复到之前的两个holder中。 最后调用publishRequestHandledEvent 进行事件发布， 告知一些感兴趣的listener 一个请求处理已经完成。
LocaleContext ： 里面存放着本地化信息， 如zh-cn
。RequestAttributes： 是spring 的一个接口， 通过他可以get、set 一些属性， 根据scope 参数判断操作是request 还是session 作用域， 这里具体使用的是ServletRequestAttributes 封装了request 、 response 、session ， 根据scope 来判定从哪个作用域取数据， 我们先看看holder 是啥

public abstract class LocaleContextHolder {
    private static final java.lang.ThreadLocal localeContextHolder;
    private static final java.lang.ThreadLocal inheritableLocaleContextHolder;

就是一个抽象类， 但是里面有两个ThreadLocal 类型的静态属性， 可以直接拿来用。总的来说就是在调用真正的doService 之前 先把之前的本地化信息和一些作用域范围内的信息保存到临时变量中，把当前请求的以上信息放在ThreadLocal 中， 然后在我们的业务中无论是controller 还是service 可以直接拿来用， 而不用在controller 用request 去取，然后传递到service 了。 最后在finally 中又把 那些之前信息给放回了holder

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;

        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = buildLocaleContext(request);

        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

        initContextHolders(request, localeContext, requestAttributes);

        try {
            doService(request, response);
        }
        catch (ServletException ex) {
            failureCause = ex;
            throw ex;
        }
        catch (IOException ex) {
            failureCause = ex;
            throw ex;
        }
        catch (Throwable ex) {
            failureCause = ex;
            throw new NestedServletException("Request processing failed", ex);
        }

        finally {
            resetContextHolders(request, previousLocaleContext, previousAttributes);
            if (requestAttributes != null) {
                requestAttributes.requestCompleted();
            }

            if (logger.isDebugEnabled()) {
                if (failureCause != null) {
                    this.logger.debug("Could not complete request", failureCause);
                }
                else {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        logger.debug("Leaving response open for concurrent processing");
                    }
                    else {
                        this.logger.debug("Successfully completed request");
                    }
                }
            }

            publishRequestHandledEvent(request, startTime, failureCause);
        }
    }

CompletionService 妙用

对于批量执行task切均需要拿到返回结果的时候， CompletionService是用武之地


import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CompletionServiceTest {

    static int numThread =100;
    static ExecutorService executor = Executors.newFixedThreadPool(numThread);

    public static void main(String[] args) throws Exception{
        //data表示批量任务
        int[] data =new int[100];
        for(int i=1;i<100000;i++){
            int idx =i % 100;
            data[idx] =i;
            if(i%100==0){
                testCompletionService(data);
                data =new int[100];
            }
        }
    }

    private static void testCompletionService(int [] data) throws Exception{       
        CompletionService ecs = new ExecutorCompletionService(executor);
        for(int i=0;ifinal Integer t=data[i];
            ecs.submit(new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(new Random().nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return t;
                }
            });
        }
        //CompletionService会按处理完后顺序返回结果
        List res =new ArrayList();
        for(int i = 0;i f = ecs.take();
            res.add(f.get());
        }              
        System.out.println(Thread.currentThread().getName()+":"+res);
    }

    private static void testBasicFuture(int [] data) throws Exception{     
        List> res =new ArrayList>();
        for(int i=0;ifinal Integer t=data[i];
            Future future=executor.submit(new Callable() {
                public Object call() {
                    return t;
                }
            });
            res.add(future);
        }      

        for(int i = 0;i f = res.get(i);
            Object rObject =f.get();
            System.out.print(":"+rObject);
        }              
        System.out.println("LN");
    }
} 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(并发多线程)

        

            

                
    
                    
  • volatile 关键字
                        经常发呆的柴犬
c语言
                        
    volatile关键字在编程中,尤其是在C和C++语言中,用于指示编译器一个变量可能会在程序的执行期间被意外的更改,因此每次使量的时候都必须从原始的内存位置读取它的值,而不是使用缓存中的值。这个关键字提醒编译器不要对这个变量的读取和写入优化,以保证程序运行的正确性。使用场景1.并发多线程访问的变量:在多线程编程中,如果一个变量可能被一个以上线程同时访问和修改,则应该将该变量声明为volatile。
    
                    
    • 
                    
  • 高并发多线程安全之原子性问题、CAS机制及问题解决方案
                        踩踩踩从踩
java高并发多线程java线程安全多线程
                        
    多线程编程之java内存模型(JMM)与可见性问题前言在java内存模型中，对多线程间交互，涉及到原子性问题、可见性问题、以及有序性问题；这篇文章主要讲解的是多线程高并发的原子性问题，以及解决原子性问题、CAS机制、自旋锁的优缺点、以及ABA问题等解决什么是原子操作定义即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。通过下面代码来看出来publicclassC
    
                    
    • 
                    
  • Go_协程与管道
                        从春到秋冬
Golang学习golangjava算法
                        
    协程（goroutine）基本介绍进程和线程的关系；进程是系统进行资源分配和调度的基本单位一个进程可以有多个线程同一个进程的多个线程并发的执行并发和并行多线程程序在单核上进行，就是并发多线程程序在多核上运行，就是并行Go协程和Go主线程Go主线程（有的程序员直接称为线程/也可理解成进程）：一个Go线程上，可以起多个协程，协程是轻量级的线程【编译器做了优化】Go协程的特点：有独立的栈空间共享程序堆空
    
                    
    • 
                    
  • java并发多线程面试_Java多线程并发面试问答
                        cunchi4221
python多线程面试java编程语言
                        
    java并发多线程面试TodaywewillgothroughJavaMultithreadingInterviewQuestionsandAnswers.WewillalsolookintoConcurrencyinterviewquestionsandanswersbecausebothmultithreadingandconcurrencygohandinhand.今天，我们将讨论Java多
    
                    
    • 
                    
  • Java并发多线程的6种状态
                        Jack_Tpy
Java多线程
                        
    线程状态线程可以有以下6种状态1.New(新建)2.Runnable(可运行)3.Blocked(被阻塞）4.Waiting(等待）5.Timedwaiting(计时等待）6.Terminated(被终止新创建线程(New)当用new创建了一个线程,但是该线程还没有开始运行时,那么他的状态就是new。可运行线程(Runnable)一旦调用start方法,则该线程处于runnable状态，处于该状态
    
                    
    • 
                    
  • Python并发多线程案例展示
                        白码会说
python多线程python多进程软件测试测试工程师
                        
    Timewilltell.多线程的优点：使用线程可以把占据长时间的程序中的任务放到后台去处理。用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可弹出一个进度条来显示处理的进度。程序运行速度加快。在一些等待的任务实现上，如用户输入、文件读写、网络收发数据等。在这种情况下可以释放一些资源如内存占用等等。每个线程都有一组CPU寄存器，称为线程的上下文。该上下文反映了线程上次运行该线程
    
                    
    • 
                    
  • Java 锁优化的方法和思路
                        L千年老妖

                        
    java程序开发中一旦用到锁，就表示采用了阻塞形式的并发——一种最糟糕的并发等级。而锁优化就是希望在高并发多线程程序当中将涉及到有锁动作的相关代码尽可能的加以改进，使执行效率尽可能地得到提升。当然就算将这种用到了锁的代码优化到极致，其性能也无法超越无锁，毕竟锁会导致线程挂起（相对来说相当耗时及浪费资源）。但是我们要想办法让这种损耗降到最低，这是锁优化的出发点。一般来说，java锁优化有如下思路或方
    
                    
    • 
                    
  • dart 07.3 并发多线程
                        Applicaton
Dart多线程Isolatedart
                        
    什么是isolatedart虽然是一个单线程语言但是不代表他不支持多线程并发在dart中线程不叫线程叫做isolate(隔离区)所有的代码都运行在这类似于线程但不共享内存的独立工作程序，仅通过消息进行通信。每个isolate都有一个完整的事件循环机制，每个隔离区都有自己的内存堆，确保每个隔离区的状态都不会被其他隔离区访问。这意味着在一个Isolate中运行的代码与另外一个Isolate不存在任何关
    
                    
    • 
                    
  • Python之并发多线程操作
                        辉辉辉辉辉辉辉辉辉辉辉
pythonpython开发语言
                        
    一、threading模块介绍multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性二、开启线程的两种方式方式一#方式一fromthreadingimportThreadimporttimedefsayhi(name):time.sleep(2)print('%ssayhello'%name)if__name__=='__main__':t=Threa
    
                    
    • 
                    
  • 【C++】多线程编程一（初识并发和多线程）
                        Jacky_Feng
多线程编程开发语言c++
                        
    目录一、并发和并行的概念1.并发2.并行3.并发和并行的区别二、并发的途径多进程并发多线程并发三、C++11相关多线程编程的头文件一、并发和并行的概念1.并发并发：指同一时刻只能有一条指令执行，但是多个进程指令被快速地轮换执行，使得在宏观上具有多个进程同时执行的效果，但实际在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。2.并行并行：指同一时刻，有多条指令在多个处理器上同
    
                    
    • 
                    
  • 多线程并发 面试 java_JAVA并发多线程的面试问题及答案:java多线程并发面试题
                        九月之秋
多线程并发面试java
                        
    多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。在这里，从面试的角度列出了大部分重要的问题，但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。下面就由小编为大家介绍一下JAVA并发多线程的面试问题及答案的文章，欢迎阅读。JAVA并发多线程的面试问题及答案篇11)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行?这个线程问题通
    
                    
    • 
                    
  • Java初级编程9个重要的知识点你知道几个？
                        小宇java

                        
    关于java编程的知识，有人会问哪些是重要的知识点，不知道大家是否都知道呢？现在小编给大家分享以下9点内容，仔细看咯！1.多线程并发多线程是Java中普遍认为比较难的一块。多线程用好了可以有效提高cpu使用率，提升整体系统效率，特别是在有大量IO操作阻塞的情况下;但是它也是一柄双刃剑，如果用不好，系统非但提升不大，或者没有提升，而且还会带来多线程之间的调试时等问题。在多线程中内容有很多，只是简单说
    
                    
    • 
                    
  • CountDownLatch源码剖析
                        bingaPang
java并发并发编程juc锁源码
                        
    目录AQS中共享锁的实现AQS中共享锁相关的方法CountDownLatch原理浅析CountDownLatch源码剖析在并发多线程之AQS源码分析（上）和并发多线程之AQS源码分析（下）中分析了AQS的独占锁下的方法。当然AQS也提供了共享锁的实现。接下来就先简单分析一下AQS中关于共享锁的实现原理流程及AQS源码，然后再剖析一下基于AQS实现的共享锁CountDownLatch。AQS中共享锁
    
                    
    • 
                    
  • ExecutorService、Callable、Future实现有返回结果的多线程原理解析
                        朱季谦
Javajava源码软件
                        
    原创/朱季谦在并发多线程场景下，存在需要获取各线程的异步执行结果，这时，就可以通过ExecutorService线程池结合Callable、Future来实现。我们先来写一个简单的例子——publicclassExecutorTest{publicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException{Ex
    
                    
    • 
                    
  • Netty Review - 从BIO到NIO的进化推演
                        小小工匠
【Netty】nio
                        
    文章目录BIODEMO1DEMO2小结论单线程BIO的缺陷BIO如何处理并发多线程BIO服务器的弊端NIONIO要解决的问题模拟NIO方案一：（等待连接时和等待数据时不阻塞）方案二（缓存Socket，轮询数据是否准备好）方案二存在的问题NIO是如何解决这些问题的使用select/poll/epoll和直接在应用层做轮询的区别select底层逻辑poll的底层逻辑epoll的底层逻辑BIO要讲明白B
    
                    
    • 
                    
  • 高并发、多线程、分布式都不懂，你拿什么跳槽阿里、腾讯、京东？
                        小课VIP

                        
    Java多线程与高并发实战实践先来看看高并发多线程一些大厂并发面试题，看你能答出几道！（1）synchronized的CPU原语级别是如何实现的？（2）无锁、偏向锁、轻量级锁、重量级锁有什么差别，升级过程如何？（3）线程间通信，同机器进程间通信，跨机器进程间通信，各有什么方法？（4）下列三种业务，应该如何使用线程池：高并发、任务执行时间短的业务并发不高、任务执行时间长的业务并发高、业务执行时间长的
    
                    
    • 
                    
  • LongAdder源码分析
                        ThiAgoCoding

                        
    LongAdder的由来LongAdder是jdk1.8新增的一个原子性的操作，AtomicLong也是一个原子性的操作，AtomicLong使用CAS算法，尝试修改值，但是在修改失败后一直处于自旋修改，非常消耗CPU资源，正是这个原因，在高并发多个线程同时操作同一个资源会造成大量的线程修改值失败，大量线程处于自旋修改值状态，严重浪费CPU资源，直接降低并发性，AtomicLong在高并发多线程修
    
                    
    • 
                    
  • C++并发多线程--std::unique_lock的使用
                        晓晓纳兰容若
多线程并发学习笔记c++
                        
    目录1--std::unique_lock的使用1-1--std::adopt_lock参数1-2--std::try_to_lock参数1-3--std::defer_lock参数1-4--互斥量所有权转移1--std::unique_lock的使用常用成员函数：①lock():加锁；②unlock():解锁；③try_lock():不阻塞地尝试给互斥量加锁，获取锁时返回true，否则返回fal
    
                    
    • 
                    
  • Redis单线程模型介绍
                        鱼小洲
Redisredisredis单线程io多路复用epollreactor
                        
    目录Redis单线程模型处理Redis使用单线程，但是还能保证高性能，这是为什么Reactor模式如何保证高并发多线程IO的致命缺陷单线程的Reactor模型单线程模式的缺点多线程的Reactor模型Reactor的进一步改进Reactor编程的优点和缺点总结Redis单线程模型处理其实在写这篇文章的时候，心里也充满了疑惑性。但是还是将自己心里的所想表达出来，望各位大佬们能够详细解答一下；众所周知
    
                    
    • 
                    
  • golang笔记18--go并发多线程
                        昕光xg
Golanggolang笔记开发语言
                        
    golang笔记18--go并发多线程介绍核心用法MutexRWMutexWaitGroupCondOncemapPoolContextselect注意事项参考文档介绍大家都知道go语言近年来越来越火了，其中有一个要点是go语言在并发场景有很高的性能，比如可以通过启动很多个goroutine来执行并发任务，通过Channel类型实现goroutine之间的数据交流。当我们想用go实现高并发的时候，
    
                    
    • 
                    
  • JUC并发多线程进阶
                        早上真起不来！
Java基础juc锁多线程
                        
    笔记整理来源B站UP主狂神说Javahttps://space.bilibili.com/95256449/JUC并发多线程进阶1、什么是JUC源码+官方文档JUC是javautilconcurrent面试高频问JUC~！java.util是Java的一个工具包~业务：不会通过普通的线程代码Thread来实现Runnable：没有返回值、效率相比于Callable相对较低！2、线程和进程进程：一个
    
                    
    • 
                    
  • Java学习知识点目录（博客目录）
                        mocas_wang

                        
    csdn博客：mocas_wang简介：博客多为总结学习内容，博客中若有错误，可指出。持续更新中，不定时更新，目录顺序经常变动。分类目录1Git2Linux3java基础4数据库mysql5javaWeb6安装教程7大数据hadoop8JVM9Python数据分析处理10中间件11设计模式12并发多线程13随笔记录14性能优化15正则表达式16操作系统17Spring生态18计算机网络19数据结构
    
                    
    • 
                    
  • lv7 嵌入式开发-网络编程开发 08 TCP并发功能
                        4IOT
嵌入式开发网络tcp/iplinux
                        
    目录1TCP多进程并发1.1现象：1.2多进程并发2僵尸进程处理3TCP并发多线程4练习1TCP多进程并发1.1现象：之前的代码，先关服务端，再次打开会出现错误bind:Addressalreadyinuse使用setsockopt地址快速重用可解决（后续会讲套接字设置）#include#include#include#include#include#include#include#include
    
                    
    • 
                    
  • 零基础入门推荐系统——task03：多路召回
                        从白玉石

                        
    多路召回策略，是指采用不同的策略、特征或简单模型，分别召回一部分候选集，然后将候选集合并在一起用于后续排序模型使用。多路召回通常需要在计算速度和召回率之间权衡选择，简单的召回策略可以快速召回候选集，不同角度设计的召回策略可以尽量满足召回率。多路召回中，每个策略之间毫不相关，一般可以写并发多线程同时进行。多路召回.png此次多路召回策略包含：YoutubeDNN召回YoutubeDNN召回可直接获取
    
                    
    • 
                    
  • GCD多线程并发执行多任务并同步返回
                        methodname

                        
    前面有写过一篇.NET使用WaitHandle开启并发多线程查询并同步返回在.NET中有WaitHandle可以进行多任务多线程的操作，作为成熟的语言OC中是否也有同样的存在，于是我将目光转向了苹果杰作GCD.终于，我在官方的文档中找到了dispatch_block_waitdispatch_group_wait同步等待先前提交的块对象完成;如果在指定的超时时间结束之前块没有完成，则返回。参数gr
    
                    
    • 
                    
  • 8.gec6818开发板通过并发多线程实现电子相册 智能家居 小游戏三合一完整项目
                        黎明的前夜
基于粤嵌智能家居linuxc语言嵌入式硬件ubuntu
                        
    并发前面编写的程序都是从mian函数开始，从上往下执行，称为顺序执行假设一个程序需要I输入C计算P输出，以顺序执行三个上述程序，则其执行过程如下：程序内部的语句是一条一条的执行，如果要运行多个程序，这些程序也是一个一个的依次执行，若上述的三种操作，每种操作需要的时间都是t，则执行上述三个程序共需要9t而在上述程序的执行过程中，只有计算需要用到cpu==》CPU的利用率只有3t/9t=33.33%顺
    
                    
    • 
                    
  • C++并发多线程--std::future_status、std::shared_future和std::atomic的使用
                        布吉岛呀~
多线程并发学习笔记c++
                        
    目录1--std::future_status的使用2--std::shared_future的使用3--std::atomic的使用1--std::future_status的使用std::future_status成员函数含有三种状态：timeout（执行超时）、ready（执行完毕）和deferred（延迟执行），其中deferred状态需要用std::launch::deferred对线程
    
                    
    • 
                    
  • C++并发多线程--条件变量std::condition_variable的使用
                        布吉岛呀~
多线程并发学习笔记c++
                        
    1--std::condition_variablestd::condition_variable创建条件变量对象，其可以使用wait(),notify_one()等成员函数来实现多线程的条件交互，具体使用方法如下：#include#include#include#include#includeclassSample{public://模型发送消息voidinMsgRecvQueue(){for(
    
                    
    • 
                    
  • C++并发多线程--std::async、std::packaged_task和std::promise的使用
                        布吉岛呀~
多线程并发学习笔记c++
                        
    目录1--std::async的使用2--std::packaged_task的使用3--std::promise的使用1--std::async的使用std::async用于启动一个异步任务，并返回一个std::future对象；std::future对象里含有异步任务线程入口函数的结果；std::launch::deferred表示调用线程入口函数将会被延迟到std::future的wait(
    
                    
    • 
                    
  • C++并发多线程--单例设计模式和双重检查锁
                        布吉岛呀~
多线程并发学习笔记c++
                        
    目录1--单例设计模式2--双重检查锁3--std::call_once()的使用1--单例设计模式单例设计模式要求某一个类最多创建一个对象，这个对象即单例对象（全局唯一实例对象）；单例设计模式可以分为：①懒汉式（当需要实例时才去加载）；②饿汉式（程序一开始就加载这个实例）；若一个类对象比较复杂和庞大，并且是可以复用的，当频繁地去创建和销毁类对象时就会造成巨大的性能浪费，通过单例设计模式将这个类对
    
                    
    • 
                                
  • ios内付费
                                    374016526
ios内付费
                                    
    近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。 
  
具体使用如下: 
这里的sender其实就是调用者，这里主要是为了回调使用。 
[KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
    
                                
    • 
                                
  • 20 款优秀的 Linux 终端仿真器
                                    brotherlamp
linuxlinux视频linux资料linux自学linux教程
                                    
      
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。） 
你能从开源世界中找到大量的终端仿真器，它们
    
                                
    • 
                                
  • Solr Deep Paging(solr 深分页)
                                    eksliang
solr深分页solr分页性能问题
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2148370 
作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述 
长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
    
                                
    • 
                                
  • 数据库面试题
                                    18289753290
面试题 数据库
                                    
    1.union ,union all 
网络搜索出的最佳答案： 
union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 
Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； 
Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 
2.索引有哪些分类？作用是
    
                                
    • 
                                
  • Android TV屏幕适配
                                    酷的飞上天空
android
                                    
    先说下现在市面上TV分辨率的大概情况 
两种分辨率为主 
1.720标清，分辨率为1280x720. 
屏幕尺寸以32寸为主，部分电视为42寸 
2.1080p全高清，分辨率为1920x1080 
屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有 
  
适配遇到问题，已1080p尺寸为例： 
分辨率固定不变，屏幕尺寸变化较大。 
如：效果图尺寸为1920x1080，如果使用d
    
                                
    • 
                                
  • Timer定时器与ActionListener联合应用
                                    永夜-极光
java
                                    
    功能:在控制台每秒输出一次 
  
代码: 
package Main;
import javax.swing.Timer;
 import java.awt.event.*;

 public class T {
    private static int count = 0; 

    public static void main(String[] args){

    
                                
    • 
                                
  • Ubuntu14.04系统Tab键不能自动补全问题解决
                                    随便小屋
Ubuntu 14.04
                                    
    Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下： 
  
1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） 
sudo vi /etc/bash.bashrc 
 接下来会提示输入密码 
2、找到文件中的下列代码 
#enable bash completion in interactive shells
#if
    
                                
    • 
                                
  • 学会人际关系三招 轻松走职场
                                    aijuans
职场
                                    
    要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。 
　　第一，多汇报 
 最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。 
　　第二，勤沟通 
 团队的力
    
                                
    • 
                                
  • 《O2O：移动互联网时代的商业革命》读书笔记
                                    aoyouzi
读书笔记
                                    
    移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。 
  
O2O：Online to OffLine 线上线下活动 
O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。 
  
手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。 
  
线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
    
                                
    • 
                                
  • js实现图片随鼠标滚动的效果
                                    百合不是茶
JavaScript滚动属性的获取图片滚动属性获取页面加载
                                    
    1,获取样式属性值 
top  与顶部的距离
left  与左边的距离
right 与右边的距离
bottom 与下边的距离
zIndex 层叠层次 
  
  例子:获取左边的宽度,当css写在body标签中时 
<div id="adver" style="position:absolute;top:50px;left:1000p
    
                                
    • 
                                
  • ajax同步异步参数async
                                    bijian1013
jqueryAjaxasync
                                    
            开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。 
        格式： 
$.ajax({ type: 'POST', ur
    
                                
    • 
                                
  • Webx3框架（1）
                                    Bill_chen
eclipsespringmaven框架ibatis
                                    
    Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发； 
采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 
Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
    
                                
    • 
                                
  • 【MongoDB学习笔记五】MongoDB概述
                                    bit1129
mongodb
                                    
    MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
    
                                
    • 
                                
  • spring/hibernate/struts2常见异常总结
                                    白糖_
Hibernate
                                    
     
 Spring 
 
①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 
缺少aspectjweaver.jar，该jar包常用于spring aop中 
  
②java.lang.ClassNotFoundException: org.sprin
    
                                
    • 
                                
  • jquery easyui表单重置(reset)扩展思路
                                    bozch
formjquery easyuireset
                                    
    在jquery easyui表单中 尚未提供表单重置的功能，这就需要自己对其进行扩展。 
扩展的时候要考虑的控件有： 
 combo,combobox,combogrid,combotree,datebox,datetimebox 
需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。 
在所有的reset方法添加完毕之后，就需要对fo
    
                                
    • 
                                
  • 编程之美-烙饼排序
                                    bylijinnan
编程之美
                                    
    
package beautyOfCoding;

import java.util.Arrays;

/*
 *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。
 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码：
 */

    
                                
    • 
                                
  • Struts1.X 源码分析之ActionForm赋值原理
                                    chenbowen00
struts
                                    
    struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。 
 
如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
    
                                
    • 
                                
  • [空天防御与经济]在获得充足的外部资源之前,太空投资需有限度
                                    comsci
资源
                                    
     
      这里有一个常识性的问题: 
 
      地球的资源,人类的资金是有限的,而太空是无限的..... 
 
      就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... 
 
&
    
                                
    • 
                                
  • ORACLE临时表—ON COMMIT PRESERVE ROWS
                                    daizj
oracle临时表
                                    
    ORACLE临时表 转 
临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前 
会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。 
创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
    
                                
    • 
                                
  • 基于Nginx XSendfile+SpringMVC进行文件下载
                                    denger
应用服务器Webnginx网络应用lighttpd
                                    
        在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 
 
   @RequestMapping("/courseware/{id}") 
   public void download(@PathVariable("id") String courseID, HttpServletResp
    
                                
    • 
                                
  • scanf接受char类型的字符
                                    dcj3sjt126com
c
                                    
    /*
	2013年3月11日22:35:54
	目的：学习char只接受一个字符
*/
# include <stdio.h>

int main(void)
{
	int i;
	char ch;

	scanf("%d", &i);
	printf("i = %d\n", i);
	scanf("%
    
                                
    • 
                                
  • 学编程的价值
                                    dcj3sjt126com
编程
                                    
    发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助 
  
像这位朋友学习:   
http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html 
  
 
  VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
    
                                
    • 
                                
  • 二维数组（矩阵）对角线输出
                                    飞天奔月
二维数组
                                    
    今天在BBS里面看到这样的面试题目, 
  
1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组  
{ 1 2 3 4 }
{ 5 6 7 8 }
{ 9 10 11 12 }
{13 14 15 16 } 
打印顺序  
4
3 8
2 7 12
1 6 11 16
5 10 15
9 14
13 
要
    
                                
    • 
                                
  • Ehcache（08）——可阻塞的Cache——BlockingCache
                                    234390216
并发ehcacheBlockingCache阻塞
                                    
    可阻塞的Cache—BlockingCache 
  
       在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
    
                                
    • 
                                
  • mysqldiff对数据库间进行差异比较
                                    jackyrong
mysqld
                                    
      mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构 
   如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 
 
1） 基本用法 
   mysqldiff --server1=admin:12345
    
                                
    • 
                                
  • spring data jpa 方法中可用的关键字
                                    lawrence.li
javaspring
                                    
    spring data jpa 支持以方法名进行查询/删除/统计。 
查询的关键字为find 
删除的关键字为delete/remove (>=1.7.x) 
统计的关键字为count (>=1.7.x) 
  
修改需要使用@Modifying注解 
@Modifying
@Query("update User u set u.firstna
    
                                
    • 
                                
  • Spring的ModelAndView类
                                    nicegege
spring
                                    
    项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ 
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * yo
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(13) - rsync、Amanda
                                    rensanning
centos
                                    
    （一）rsync 
 
Server端 
 
# yum install rsync
# vi /etc/xinetd.d/rsync
    service rsync
    {
        disable = no
        flags           = IPv6
        socket_type     = stream
        wait    
    
                                
    • 
                                
  • Learn Nodejs 02
                                    toknowme
nodejs
                                    
    （1）npm是什么   
npm is the package manager for node 
官方网站：https://www.npmjs.com/ 
npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作 
在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 
&nb
    
                                
    • 
                                
  • Spring MVC 拦截器
                                    xp9802
spring mvc
                                    
    Controller层的拦截器继承于HandlerInterceptorAdapter 
 
 HandlerInterceptorAdapter.java   1  public   abstract   class  HandlerInterceptorAdapter  implements  HandlerIntercep
    
                                
    •