线程封闭

最新推荐文章于 2024-05-06 21:32:45 发布
最新推荐文章于 2024-05-06 21:32:45 发布
阅读量39 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/sunliyuan/p/11257204.html
版权

 

 

把对象封装到一个线程中，只有一个线程能看到这个对象。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class ConcurrencyApplication extends WebMvcConfigurerAdapter {
    public static void main(String[] args) {
        SpringApplication.run(ConcurrencyApplication.class,args);
    }
    @Bean
    public FilterRegistrationBean httpFilter(){
        FilterRegistrationBean registrationBean=new FilterRegistrationBean();
        registrationBean.setFilter(new HttpFilter());
        registrationBean.addUrlPatterns("/threadLocal/*");
        return registrationBean;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new HttpInterceptor()).addPathPatterns("/**");
    }
}

　　

public class RequestHolder {
    private final static ThreadLocal<Long> requestHolder=new ThreadLocal<>();
    public static void add(Long id){
        requestHolder.set(id);
    }
    public static Long getId(){
        return requestHolder.get();
    }
    public static void remove(){
        requestHolder.remove();
    }

　　

import com.example.threadLocal.RequestHolder;
import lombok.extern.slf4j.Slf4j;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Slf4j
public class HttpFilter  implements Filter  {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
       HttpServletRequest request=(HttpServletRequest) servletRequest;
       log.info("do filter,{},{}",Thread.currentThread().getId(),request.getServletPath());
       RequestHolder.add(Thread.currentThread().getId());
       filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException{

    }

    @Override
    public void destroy() {

    }
}

　　

import com.example.threadLocal.RequestHolder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@Slf4j
public class HttpInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("preHandle");
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        RequestHolder.remove();
        log.info("afterCompletion");
        return;
    }
}

　　

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class ConcurrencyApplication extends WebMvcConfigurerAdapter {
    public static void main(String[] args) {
        SpringApplication.run(ConcurrencyApplication.class,args);
    }
    @Bean
    public FilterRegistrationBean httpFilter(){
        FilterRegistrationBean registrationBean=new FilterRegistrationBean();
        registrationBean.setFilter(new HttpFilter());
        registrationBean.addUrlPatterns("/threadLocal/*");
        return registrationBean;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new HttpInterceptor()).addPathPatterns("/**");
    }
}

　　

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class StringExample2 {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static StringBuffer stringBuffer=new StringBuffer();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",stringBuffer.length());
    }
    private static void update(){
        stringBuffer.append("1");
    }
}

　　

public class StringExample1 {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static StringBuilder stringBuilder=new StringBuilder();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",stringBuilder.length());
    }
    private static void update(){
        stringBuilder.append("1");
    }
}

　　

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@NotThreadSafe   //线程不安全
public class HashSetExample {
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Set<Integer> set=new HashSet<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",set.size());
    }
    private static void update(int i){
        set.add(i);
    }
}

　　

import com.example.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import  java.util.ArrayList;
import java.util.List;

@Slf4j
@NotThreadSafe
//执行的结果并不是5000，线程不安全
public class ArrayListExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static List<Integer> list=new ArrayList<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@NotThreadSafe
public class HashMapExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Map<Integer,Integer> map=new HashMap<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",map.size());
    }
    private static void update(int i){
        map.put(i,i);
    }
}

　　

import java.util.Vector;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class VectorExample1 {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Vector<Integer> list=new Vector<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

import java.util.Vector;

@NotThreadSafe
public class VectorExample2 {
    private static Vector<Integer> vector=new Vector<>();

    public static void main(String[] args) {
        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            Thread thread = new Thread() {
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        vector.remove(i);
                    }
                }
            };
            Thread thread2 = new Thread() {
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        vector.get(i);
                    }
                }
            };
            thread.start();
            thread2.start();
        }
    }
}

　　 

import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
//线程安全
public class HashTableExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Map<Integer,Integer> map=new Hashtable<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",map.size());
    }
    private static void update(int i){
        map.put(i,i);
    }
}

　　

 

import com.example.annoations.ThreadSafe;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class CollectionsExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static List<Integer> list= Collections.synchronizedList(Lists.newArrayList());

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

import com.example.annoations.ThreadSafe;
import com.google.common.collect.Sets;
import lombok.extern.slf4j.Slf4j;
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class CollectionsSetExample {
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Set<Integer> set= Collections.synchronizedSet(Sets.newHashSet());

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",set.size());
    }
    private static void update(int i){
        set.add(i);
    }
}

　　

import com.example.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class CollectionsHashMapExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Map<Integer,Integer> map= Collections.synchronizedMap(new HashMap<>());

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",map.size());
    }
    private static void update(int i){
        map.put(i,i);
    }
}

　　

import java.util.Iterator;
import java.util.Vector;
public class VectorExample3 {
    //java.util.ConcurrentModificationException
    private static  void test1(Vector<Integer> v1){
       for(Integer i:v1){
           if(i.equals(3)){
               v1.remove(i);
           }
       }
    }
    //java.util.ConcurrentModificationException
    private static  void test2(Vector<Integer> v1){
       Iterator<Integer> iterator=v1.iterator();
       while (iterator.hasNext()){
           Integer i=iterator.next();
           if(i.equals(3)){
               v1.remove(i);
           }
        }
    }
    //成功
    private static  void test3(Vector<Integer> v1){
        for(int i=0;i<v1.size();i++){
            if(v1.get(i).equals(3)){
                v1.remove(i);
            }
        }
    }
    public static void main(String[] args) {
        Vector<Integer> vector=new Vector<>();
        vector.add(1);
        vector.add(2);
        vector.add(3);

        test2(vector);
    }
}

　　

适用读多写少的场景

设计思想：读写分离，最终一致性，使用时另外开辟空间，读不需要加锁，写需要加锁

import lombok.extern.slf4j.Slf4j;
import java.util.List;
import java.util.concurrent.*;

@Slf4j
public class CopyOnWriteArrayListExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static List<Integer> list=new  CopyOnWriteArrayList<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

 

import lombok.extern.slf4j.Slf4j;
import java.util.Set;
import java.util.concurrent.*;

@Slf4j
public class ConcurrentSkipListSetExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Set<Integer> list=new ConcurrentSkipListSet<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

import lombok.extern.slf4j.Slf4j;
import java.util.Set;
import java.util.concurrent.*;

@Slf4j
public class CopyOnWriteArraySetExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Set<Integer> list=new CopyOnWriteArraySet<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",list.size());
    }
    private static void update(int i){
        list.add(i);
    }
}

　　

concurrentHashMap不允许空值

ConcurrentSkipListMap的key是有序的

import com.example.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class ConcurrentHashMap {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Map<Integer,Integer> map=new java.util.concurrent.ConcurrentHashMap<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",map.size());
    }
    private static void update(int i){
        map.put(i,i);
    }
}

　　

import com.example.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class ConcurrentSkipListMapExample {
    //请求总数
    public static  int clientTotal=5000;
    //同时并发执行的线程数
    public static int threadTotal=200;
    public static Map<Integer,Integer> map=new java.util.concurrent.ConcurrentSkipListMap<>();

    public static void main(String[] args) throws Exception{
        ExecutorService executorService= Executors.newCachedThreadPool();
        final Semaphore semaphore=new Semaphore(threadTotal);
        final CountDownLatch countDownLatch=new CountDownLatch(clientTotal);
        for(int i=0;i<clientTotal;i++){
            final  int count=i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                }catch (Exception e){
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size{}",map.size());
    }
    private static void update(int i){
        map.put(i,i);
    }
}

　　

 

 

转载于:https://www.cnblogs.com/sunliyuan/p/11257204.html

weixin_30546189
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java线程封闭之栈封闭和ThreadLocal
08-25
主要介绍了java线程封闭之栈封闭和ThreadLocal,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
1.1.4 线程封闭
「南小鸟」的博客
08-27 98
1、线程封闭的概念 多线程访问共享可变数据时，涉及到线程间数据同步的问题。并不是所有时候都要用到共享数据， 所以线程封闭的概念就提出来了。 数据都被封闭在各自的线程之中，就不需要同步；这种通过将数据封闭在线程中而避免使用同步的 技术称为线程封闭。 线程封闭的具体体现有：ThreadLocal、局部变量。 2、ThreadLocal ...
Java线程封闭
Linux,Java,SpringBoot,Python,Lua略知一点
01-05 184
把对象封装到一个线程里,只有一个线程可以看到该对象,那么就算这个对象不是线程安全的,也不会出现任何线程问题,因为它只能在一个线程中被访问。 Ad-hoc线程封闭:程序控制实现,非常脆弱,最糟糕,忽略。 堆栈封闭:简单的说就是局部变量,无并发问题。多线程访问同一个方法时,方法中的局部变量会被拷贝一份到线程栈中。方法的局部变量不是被多线程共享的,不会出现线程安全问题,能用局部变量就不要用全局变量,全局变量容易发生并发问题,注意全局变量不是全局常量。 ThreadLocal线程封闭:Java中提供一个Thr.
线程封闭简述
Jayce的博客
11-05 198
当访问共享的可变数据时，通常需要使用同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程内访问数据，就不需要同步。这种技术被称为线程封闭，它是实现线程安全性的最简单的方式之一。当某个对象封闭在一个线程中时，这种用法将会自动实现线程安全性，即便被封闭的对象本身不是线程按安全的。 Ad-hoc线程封闭：维护线程封闭性的职责完全由程序的实现来承担。Ad-hoc线程封闭是非常脆弱的，...
Java并发编程-线程封闭
liam12138的博客
01-20 313
线程封闭 当访问共享的可变数据时，通常需要使用同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程内访问数据，就不需要同步。这种技术就是线程同步，它是实现线程安全性的最简单方式之一。当某个对象封闭在一个线程中，这种用法将自动实现线程安全性，即使被封闭的对象本身不是线程安全的。 线程封闭技术的一种常见应用是 JDBC 的 Connection 对象。JDBC 规范并不要求 Connection 对象必须是线程安全的。线程从线程池中获取一个 Connection 对象，并且用该对象处理请求，使用完后再将对
线程封闭概念
void_getGFriend的博客
09-17 154
线程封闭概念 为什么要有线程封闭这个概念呢？ 多线程中访问共享可变数据时，涉及到线程间数据同步的问题。并不是所有时候都需要共享数据。所以线程封闭概念就出来了。 在Java中线程封闭该怎么做呢？ 可以通过两个方法来做 ThreadLocal 1. ThreadLocal是一个线程级别的变量，每个线程都有一个私有的独立的栈空间，而ThreadLocal就存储在这个空间。所以在高并发的情况下，ThreadLocal是绝对的线程安全的。 2. 我们可以在ThreadLocal中存储每个线程独有的数据以便线程
详解Java线程封闭类ThreadLocal
OceanSky的专栏
04-30 714
当访问共享的可变数据时，通常需要使用同步（synchronized)；一种避免使用同步的方式就是不共享数据，如：使用局部变量。Java中提供了一个ThreadLocal类来实现线程的封闭，这个类能使线程中的某个值与保存值的对象关联起来。ThreadLocal类提供了get与set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本，因此get总是返回由当前执行线程在调用set时设置...
java多线程中线程封闭详解
08-25
在本文里我们给大家分享了关于java多线程中线程封闭的知识点内容以及用法，有需要读者们可以参考下。
Java并发中线程封闭知识点详解
08-25
在本篇文章里我们给大家整理了关于Java并发中线程封闭的知识点总结内容，需要的朋友们学习参考下。
Java中的线程同步与ThreadLocal无锁化线程封闭实现
09-02
主要介绍了Java中的线程同步与ThreadLocal无锁化线程封闭实现,Synchronized关键字与ThreadLocal变量的使用是Java中线程控制的基础,需要的朋友可以参考下
java多线程安全性基础介绍.pptx
07-25
线程封闭 仅在单线程内访问数据 栈封闭 局部变量 threadLocal 为每个线程保存一个副本 类似于一个以线程id为key的map 不可变对象状态 final 关键共享资源上互斥，变并发为串行即同步 锁 分类 显示锁 ...
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1196
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1073
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
m0_74012211的博客
05-05 1113
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 912
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。
如何用Jmeter压测
最新发布
howard1209a的博客
05-06 387
可以从清华源下载，我下的是 5.6.3 版本。bin 目录打开终端，输入 Jmeter 运行Options 点 Choose language 选择中文。
Java | Leetcode Java题解之第62题不同路径
m0_57195758的博客
05-01 572
Java | Leetcode Java题解之第62题不同路径
周阳说threadlocal
10-11
ThreadLocal是Java中的一个类，用于实现线程本地变量。每个ThreadLocal对象可以维护一个线程私有的...4. 线程封闭：有时候我们希望某个对象只在单个线程中可见，不被其他线程访问到，可以通过ThreadLocal实现线程封闭。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值