Welcome to roboslyq's blog

• openJDK相关(1)-openJDK下载及目录结构

  2019-03-24

  roboslyq

  openJDK相关

  openJDK相关  openJDK下载及目录结构
  • 一、源码下载
    • 源码下载

  一、源码下载

  源码下载

  请移到官网下载http://hg.openjdk.java.net/下载。如下图所示，下载zip即可。

  

  如果下载有很慢或者报错(外网吗，可以理解），可以从我的百度网盘下载：

  链接：https://pan.baidu.com/s/1LKjP8BYnBLRwR2WnZ7SUTw 
  提取码：fhwk 
  

  graph LR
  A --> b
  

  Read All

  ---

• Java基础(2.1)-容器(Collection)

  2019-03-24

  roboslyq

  Java基础

  Java基础  Collection
  • 一、基本概念
    • 集合(Collection)
    • 集合框架(CF)
    • Java集合框架(JCF)
  • 二、JCF接口体系

  一、基本概念

  java 体系中，Map不属于Collection体系，是一类体系的集合。所以此文章不涉及Map。

  集合(Collection)

  A collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data.

  集合也叫容器，一个简单的对象，可以将多个同类型的元素封装在一起。集合(可以有多种不同实现)可提供对多个对象进行统一存储、检索、操作和聚合操作等功能。这个概念与语言无关，不仅在Java体系中需要，在C++,C#,Physon等语言体系中也有同样的概念。

  集合框架(CF)

  此定义与语言无关，集合框架(CF,Collections Framework)是一个统一呈现和操作多种集合的架构。一个集合框架主要包括以下三方面：

  • Interfaces: 接口，表示集合的抽象数据类型。接口定义了对多种不同集合的统一操作，而屏蔽了不同集合具体表示的细节。在面向对象的语言中，接口通常形成层次结构。
  • Implementations: 集合接口的具体实现。是一种可重用的数据结构。
  • Algorithms: 算法，是集合接口(Interfaces)的不同实现(Implementations)的具体实现，比如元素检索和排序等。当然，同一个算法可以应用于不同的集合接口实现，算法是可以重用的。

  Java集合框架(JCF)

  JCF(Java Collections Framework ), Java版本的集合框架实现，使用此框架有以下益处：

  • 减少编程工作量

    当然，JDK给提供了一些通用的集合实现，不需要每个开发人员自己实现相关代码，编程工作量当然少了。

  • 提高编程速度和质量

    JDK原生提供，质量是有保证的。统一接口调用，编程速度了不会差。

  • **允许不相关api之间的互操作性 **

    因为集合可以有多种不同的实现，JCF提供了不同实现互操的API。

  • **减少学习和使用新api的工作量 **

  • **减少设计新api的工作 **

  • 促进软件重用

    符合标准集合接口的新数据结构本质上是可重用的。对实现这些接口的对象进行操作的新算法也是如此。

  二、JCF接口体系

  Read All

  ---

• 如何形成自己的知识体系(草稿)

  2019-03-20

  roboslyq

  思绪乱记

  思绪乱记
  • 如何形成自己的知识体系
  • 为什么学不好记不牢
    • 怎么学
      • 一、空中鸟瞰，尽收眼底

  如何形成自己的知识体系

  本人普通Java程序员一枚，因此以下话语大多站在Java技术角度。

  为什么学不好记不牢

  很多人可能都会有这么一种感觉:自己看了很多书学习了很多知识，感觉自己好像什么都知道。但一旦向别人解释某一项技术时，自己又感觉不知从何说起，很有可能只是憋出简单的几句话来解释这项技术，但完全GET不技术的关键点。这是为何？

  个人觉得学习技术关键点有以下几个：

  1. 知识学习的时候没有深入了解技术的本质和背后的原因，只是泛泛的了解一些基本概念。
  2. 知识没有实时的进行归纳和总结，处于一个零散状态。这时知识的状态就好比奶酪，看着是一块，实则千疮百孔满目疮痍。
  3. 对知识只是死亡硬背，没有达到融汇贯通举一反三的效果。其实所有的技术底层原理都是相通的，可以灵活运用所学的原理达到触类旁通的效果。
  4. 如果把技术知识比喻成一座金字塔，那么基础原理就是这座金字塔的塔基。没有一个好的塔基，再花哨的塔顶(RPC，分布式,微服务，容器等)都是不稳的。正所谓基础不牢地动山摇。

  怎么学

  一、空中鸟瞰，尽收眼底

  我们学习一门技术时，不应该立马就扎进技术的细节里。比如阅读源码呀，这门技术某某组件怎么用呀或者是有哪些接口等等细节。而应该是跳出这门技术的细节，站在一个高度，俯视这门技术从而得到这门技术的全景图。

  这个全景图可以从以下几步来描述：

  • 是什么

    是什么，帮你快速了解这门技术有什么能力，你能用它做什么事情。

  • 为什么

    为什么，帮你快速定位这么技术产生背景(解决了什么问题)，发展历史(演化完善)是怎么样的，为什么历史是这样的。

  • 怎么用

    怎么用，经典的＂hello,world＂让你对一门技术有着最简单清晰的认识，也是最直接的认识。所以不管什么技术，先搭起HelloWorld环境总是没有错。

  • 全景视图

    这是我们对于这门技术的核心模块的拆分进而得到的知识主干视图。我们可以借助思维导图等工具来描述这个全景视图，将一门技术的核心要点梳理成一棵知识树。只不过此时的知识书只有主干，没有细节，没有开支散叶。

  ###　二、只见树木，不见森林

  这是第二个学习阶段。有了第一个阶段产出的“全景视图”，我们就不会盲目的去学习这一门技术。而是根据全景视图有步骤有重点的一步步去深入的学习，了解具体的实现技术细节，背后的设计意图等细节问题。并且不断完善全景视图，使其更准确更丰满。

  此时还可以将当前技术与其它技术进行横向比较，总结归纳其优缺点和使用场景。

  ###　三、总结，形成知识体系

  在第二步的基础上，最终得到一棵十分完整的丰满的知识体系树。我们可以使用这颗将所有的技术关联起来。进而我们向别人描述这项技术时，也可以按照这棵树从主干到分支，再到具体的细节进行深刻的描述。

  我们借助于这个知识树，进行知识回顾总结。。

  TODO….

  Read All

  ---

• SpringCloud应用系列(4.1) hystrix与Ribbon

  2019-03-17

  roboslyq

  springCloud

  springCloud  hystrix
  • 1.文章列表
  • 2.相关项目
  • 3. 服务端环境搭建
    • 3.1 依赖导入
    • 3.2 修改启动引导类
    • 3.3 application.properties配置
    • 3.4 Hystrix包装Ribbon

  1.文章列表

  1. SpringCloud应用系列(1)config配置中心
  2. SpringCloud应用系列(2)eureka服务治理
  3. SpringCloud应用系列(3.1) ribbon服务调用
  4. SpringCloud应用系列(3.2) feign负载均衡

  2.相关项目

  • 注册中心：spring-cloud-eureka
  • 服务提供者：spring-cloud-eureka-client
  • 服务消费者: spring-cloud-hystrix

  3. 服务端环境搭建

  此次环境搭建主要是hystrix + ribbon来实现。

  3.1 依赖导入

  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  </dependency>
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </dependency>
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  </dependency>
  

  3.2 修改启动引导类

  package com.roboslyq.springcloudhystrix;
  
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  import org.springframework.cloud.netflix.hystrix.EnableHystrix;
  import org.springframework.context.annotation.Bean;
  import org.springframework.web.client.RestTemplate;
  @SpringBootApplication
  @EnableDiscoveryClient
  @EnableHystrix
  public class SpringCloudHystrixApplication {
      @Bean //定义REST客户端，RestTemplate实例
      @LoadBalanced//开启负债均衡的能力
      RestTemplate restTemplate() {
          return new RestTemplate();
      }
  	public static void main(String[] args) {
  		SpringApplication.run(SpringCloudHystrixApplication.class, args);
  	}
  }
  
  

  @EnableHystrix 派生于@EnableCircuitBreaker,因此上面注解@EnableHystrix 可以用注解 @EnableCircuitBreaker来替代，最终效果一样。

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Inherited
  @EnableCircuitBreaker
  public @interface EnableHystrix {
  
  }
  
  

  3.3 application.properties配置

  #应用名称
  spring.application.name=spring-cloud-hystrix
  #端口号
  server.port=8085
  #注册中心的地址
  eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/
  
  

  3.4 Hystrix包装Ribbon

  package com.roboslyq.springcloudhystrix.service;
  
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.web.client.RestTemplate;
  
  @Service
  public class HystrixRibbonService {
  
      @Autowired
      private RestTemplate restTemplate;
  
      //指定服务失败回调方法
      @HystrixCommand(fallbackMethod = "helloError")
      public String hello() {
          String result = restTemplate.getForEntity("http://SPRING-CLOUD-EUREKA-CLIENT/hello", String.class).getBody();
          System.out.println(result);
          return  result;
      }
  	//失败回调方法
      public String helloError(){
          return "hello world is error!!!";
      }
  }
  
  

  Read All

  ---

• JDK常见源码分析(1)ClassLoader

  2019-03-13

  roboslyq

  JDK常见源码分析

  JDK常见源码分析  ClassLoader
  • ClassLoader

  ClassLoader

  Object对象是Java中所有对象的父类 。一共有12个方法。源码如下(JDK1.8):

  package java.lang;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.lang.reflect.InvocationTargetException;
  import java.net.URL;
  import java.nio.ByteBuffer;
  import java.security.AccessControlContext;
  import java.security.AccessController;
  import java.security.CodeSource;
  import java.security.PermissionCollection;
  import java.security.Principal;
  import java.security.PrivilegedAction;
  import java.security.PrivilegedActionException;
  import java.security.ProtectionDomain;
  import java.security.cert.Certificate;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Hashtable;
  import java.util.Map;
  import java.util.Set;
  import java.util.Stack;
  import java.util.Vector;
  import java.util.WeakHashMap;
  import java.util.concurrent.ConcurrentHashMap;
  import sun.misc.CompoundEnumeration;
  import sun.misc.Launcher;
  import sun.misc.PerfCounter;
  import sun.misc.Resource;
  import sun.misc.URLClassPath;
  import sun.misc.VM;
  import sun.reflect.CallerSensitive;
  import sun.reflect.Reflection;
  import sun.reflect.misc.ReflectUtil;
  import sun.security.util.SecurityConstants;
  
  public abstract class ClassLoader {
      private final ClassLoader parent;
      private final ConcurrentHashMap<String, Object> parallelLockMap;
      private final Map<String, Certificate[]> package2certs;
      private static final Certificate[] nocerts;
      private final Vector<Class<?>> classes;
      private final ProtectionDomain defaultDomain;
      private final Set<ProtectionDomain> domains;
      private final HashMap<String, Package> packages;
      private static ClassLoader scl;
      private static boolean sclSet;
      private static Vector<String> loadedLibraryNames;
      private static Vector<ClassLoader.NativeLibrary> systemNativeLibraries;
      private Vector<ClassLoader.NativeLibrary> nativeLibraries;
      private static Stack<ClassLoader.NativeLibrary> nativeLibraryContext;
      private static String[] usr_paths;
      private static String[] sys_paths;
      final Object assertionLock;
      private boolean defaultAssertionStatus;
      private Map<String, Boolean> packageAssertionStatus;
      Map<String, Boolean> classAssertionStatus;
  
      private static native void registerNatives();
  
      void addClass(Class<?> var1) {
          this.classes.addElement(var1);
      }
  
      private static Void checkCreateClassLoader() {
          SecurityManager var0 = System.getSecurityManager();
          if (var0 != null) {
              var0.checkCreateClassLoader();
          }
  
          return null;
      }
  
      private ClassLoader(Void var1, ClassLoader var2) {
          this.classes = new Vector();
          this.defaultDomain = new ProtectionDomain(new CodeSource((URL)null, (Certificate[])null), (PermissionCollection)null, this, (Principal[])null);
          this.packages = new HashMap();
          this.nativeLibraries = new Vector();
          this.defaultAssertionStatus = false;
          this.packageAssertionStatus = null;
          this.classAssertionStatus = null;
          this.parent = var2;
          if (ClassLoader.ParallelLoaders.isRegistered(this.getClass())) {
              this.parallelLockMap = new ConcurrentHashMap();
              this.package2certs = new ConcurrentHashMap();
              this.domains = Collections.synchronizedSet(new HashSet());
              this.assertionLock = new Object();
          } else {
              this.parallelLockMap = null;
              this.package2certs = new Hashtable();
              this.domains = new HashSet();
              this.assertionLock = this;
          }
  
      }
  
      protected ClassLoader(ClassLoader var1) {
          this(checkCreateClassLoader(), var1);
      }
  
      protected ClassLoader() {
          this(checkCreateClassLoader(), getSystemClassLoader());
      }
  
      public Class<?> loadClass(String var1) throws ClassNotFoundException {
          return this.loadClass(var1, false);
      }
  
      protected Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
          synchronized(this.getClassLoadingLock(var1)) {
              Class var4 = this.findLoadedClass(var1);
              if (var4 == null) {
                  long var5 = System.nanoTime();
  
                  try {
                      if (this.parent != null) {
                          var4 = this.parent.loadClass(var1, false);
                      } else {
                          var4 = this.findBootstrapClassOrNull(var1);
                      }
                  } catch (ClassNotFoundException var10) {
                  }
  
                  if (var4 == null) {
                      long var7 = System.nanoTime();
                      var4 = this.findClass(var1);
                      PerfCounter.getParentDelegationTime().addTime(var7 - var5);
                      PerfCounter.getFindClassTime().addElapsedTimeFrom(var7);
                      PerfCounter.getFindClasses().increment();
                  }
              }
  
              if (var2) {
                  this.resolveClass(var4);
              }
  
              return var4;
          }
      }
  
      protected Object getClassLoadingLock(String var1) {
          Object var2 = this;
          if (this.parallelLockMap != null) {
              Object var3 = new Object();
              var2 = this.parallelLockMap.putIfAbsent(var1, var3);
              if (var2 == null) {
                  var2 = var3;
              }
          }
  
          return var2;
      }
  
      private Class<?> loadClassInternal(String var1) throws ClassNotFoundException {
          if (this.parallelLockMap == null) {
              synchronized(this) {
                  return this.loadClass(var1);
              }
          } else {
              return this.loadClass(var1);
          }
      }
  
      private void checkPackageAccess(Class<?> var1, ProtectionDomain var2) {
          final SecurityManager var3 = System.getSecurityManager();
          if (var3 != null) {
              final int var5;
              if (ReflectUtil.isNonPublicProxyClass(var1)) {
                  Class[] var8 = var1.getInterfaces();
                  var5 = var8.length;
  
                  for(int var6 = 0; var6 < var5; ++var6) {
                      Class var7 = var8[var6];
                      this.checkPackageAccess(var7, var2);
                  }
  
                  return;
              }
  
              final String var4 = var1.getName();
              var5 = var4.lastIndexOf(46);
              if (var5 != -1) {
                  AccessController.doPrivileged(new PrivilegedAction<Void>() {
                      public Void run() {
                          var3.checkPackageAccess(var4.substring(0, var5));
                          return null;
                      }
                  }, new AccessControlContext(new ProtectionDomain[]{var2}));
              }
          }
  
          this.domains.add(var2);
      }
  
      protected Class<?> findClass(String var1) throws ClassNotFoundException {
          throw new ClassNotFoundException(var1);
      }
  
      /** @deprecated */
      @Deprecated
      protected final Class<?> defineClass(byte[] var1, int var2, int var3) throws ClassFormatError {
          return this.defineClass((String)null, var1, var2, var3, (ProtectionDomain)null);
      }
  
      protected final Class<?> defineClass(String var1, byte[] var2, int var3, int var4) throws ClassFormatError {
          return this.defineClass(var1, var2, var3, var4, (ProtectionDomain)null);
      }
  
      private ProtectionDomain preDefineClass(String var1, ProtectionDomain var2) {
          if (!this.checkName(var1)) {
              throw new NoClassDefFoundError("IllegalName: " + var1);
          } else if (var1 != null && var1.startsWith("java.")) {
              throw new SecurityException("Prohibited package name: " + var1.substring(0, var1.lastIndexOf(46)));
          } else {
              if (var2 == null) {
                  var2 = this.defaultDomain;
              }
  
              if (var1 != null) {
                  this.checkCerts(var1, var2.getCodeSource());
              }
  
              return var2;
          }
      }
  
      private String defineClassSourceLocation(ProtectionDomain var1) {
          CodeSource var2 = var1.getCodeSource();
          String var3 = null;
          if (var2 != null && var2.getLocation() != null) {
              var3 = var2.getLocation().toString();
          }
  
          return var3;
      }
  
      private void postDefineClass(Class<?> var1, ProtectionDomain var2) {
          if (var2.getCodeSource() != null) {
              Certificate[] var3 = var2.getCodeSource().getCertificates();
              if (var3 != null) {
                  this.setSigners(var1, var3);
              }
          }
  
      }
  
      protected final Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ProtectionDomain var5) throws ClassFormatError {
          var5 = this.preDefineClass(var1, var5);
          String var6 = this.defineClassSourceLocation(var5);
          Class var7 = this.defineClass1(var1, var2, var3, var4, var5, var6);
          this.postDefineClass(var7, var5);
          return var7;
      }
  
      protected final Class<?> defineClass(String var1, ByteBuffer var2, ProtectionDomain var3) throws ClassFormatError {
          int var4 = var2.remaining();
          if (!var2.isDirect()) {
              if (var2.hasArray()) {
                  return this.defineClass(var1, var2.array(), var2.position() + var2.arrayOffset(), var4, var3);
              } else {
                  byte[] var7 = new byte[var4];
                  var2.get(var7);
                  return this.defineClass(var1, var7, 0, var4, var3);
              }
          } else {
              var3 = this.preDefineClass(var1, var3);
              String var5 = this.defineClassSourceLocation(var3);
              Class var6 = this.defineClass2(var1, var2, var2.position(), var4, var3, var5);
              this.postDefineClass(var6, var3);
              return var6;
          }
      }
  
      private native Class<?> defineClass0(String var1, byte[] var2, int var3, int var4, ProtectionDomain var5);
  
      private native Class<?> defineClass1(String var1, byte[] var2, int var3, int var4, ProtectionDomain var5, String var6);
  
      private native Class<?> defineClass2(String var1, ByteBuffer var2, int var3, int var4, ProtectionDomain var5, String var6);
  
      private boolean checkName(String var1) {
          if (var1 != null && var1.length() != 0) {
              return var1.indexOf(47) == -1 && (VM.allowArraySyntax() || var1.charAt(0) != '[');
          } else {
              return true;
          }
      }
  
      private void checkCerts(String var1, CodeSource var2) {
          int var3 = var1.lastIndexOf(46);
          String var4 = var3 == -1 ? "" : var1.substring(0, var3);
          Certificate[] var5 = null;
          if (var2 != null) {
              var5 = var2.getCertificates();
          }
  
          Certificate[] var6 = null;
          if (this.parallelLockMap == null) {
              synchronized(this) {
                  var6 = (Certificate[])this.package2certs.get(var4);
                  if (var6 == null) {
                      this.package2certs.put(var4, var5 == null ? nocerts : var5);
                  }
              }
          } else {
              var6 = (Certificate[])((ConcurrentHashMap)this.package2certs).putIfAbsent(var4, var5 == null ? nocerts : var5);
          }
  
          if (var6 != null && !this.compareCerts(var6, var5)) {
              throw new SecurityException("class \"" + var1 + "\"'s signer information does not match signer information of other classes in the same package");
          }
      }
  
      private boolean compareCerts(Certificate[] var1, Certificate[] var2) {
          if (var2 != null && var2.length != 0) {
              if (var2.length != var1.length) {
                  return false;
              } else {
                  boolean var3;
                  int var4;
                  int var5;
                  for(var4 = 0; var4 < var2.length; ++var4) {
                      var3 = false;
  
                      for(var5 = 0; var5 < var1.length; ++var5) {
                          if (var2[var4].equals(var1[var5])) {
                              var3 = true;
                              break;
                          }
                      }
  
                      if (!var3) {
                          return false;
                      }
                  }
  
                  for(var4 = 0; var4 < var1.length; ++var4) {
                      var3 = false;
  
                      for(var5 = 0; var5 < var2.length; ++var5) {
                          if (var1[var4].equals(var2[var5])) {
                              var3 = true;
                              break;
                          }
                      }
  
                      if (!var3) {
                          return false;
                      }
                  }
  
                  return true;
              }
          } else {
              return var1.length == 0;
          }
      }
  
      protected final void resolveClass(Class<?> var1) {
          this.resolveClass0(var1);
      }
  
      private native void resolveClass0(Class<?> var1);
  
      protected final Class<?> findSystemClass(String var1) throws ClassNotFoundException {
          ClassLoader var2 = getSystemClassLoader();
          if (var2 == null) {
              if (!this.checkName(var1)) {
                  throw new ClassNotFoundException(var1);
              } else {
                  Class var3 = this.findBootstrapClass(var1);
                  if (var3 == null) {
                      throw new ClassNotFoundException(var1);
                  } else {
                      return var3;
                  }
              }
          } else {
              return var2.loadClass(var1);
          }
      }
  
      private Class<?> findBootstrapClassOrNull(String var1) {
          return !this.checkName(var1) ? null : this.findBootstrapClass(var1);
      }
  
      private native Class<?> findBootstrapClass(String var1);
  
      protected final Class<?> findLoadedClass(String var1) {
          return !this.checkName(var1) ? null : this.findLoadedClass0(var1);
      }
  
      private final native Class<?> findLoadedClass0(String var1);
  
      protected final void setSigners(Class<?> var1, Object[] var2) {
          var1.setSigners(var2);
      }
  
      public URL getResource(String var1) {
          URL var2;
          if (this.parent != null) {
              var2 = this.parent.getResource(var1);
          } else {
              var2 = getBootstrapResource(var1);
          }
  
          if (var2 == null) {
              var2 = this.findResource(var1);
          }
  
          return var2;
      }
  
      public Enumeration<URL> getResources(String var1) throws IOException {
          Enumeration[] var2 = (Enumeration[])(new Enumeration[2]);
          if (this.parent != null) {
              var2[0] = this.parent.getResources(var1);
          } else {
              var2[0] = getBootstrapResources(var1);
          }
  
          var2[1] = this.findResources(var1);
          return new CompoundEnumeration(var2);
      }
  
      protected URL findResource(String var1) {
          return null;
      }
  
      protected Enumeration<URL> findResources(String var1) throws IOException {
          return Collections.emptyEnumeration();
      }
  
      @CallerSensitive
      protected static boolean registerAsParallelCapable() {
          Class var0 = Reflection.getCallerClass().asSubclass(ClassLoader.class);
          return ClassLoader.ParallelLoaders.register(var0);
      }
  
      public static URL getSystemResource(String var0) {
          ClassLoader var1 = getSystemClassLoader();
          return var1 == null ? getBootstrapResource(var0) : var1.getResource(var0);
      }
  
      public static Enumeration<URL> getSystemResources(String var0) throws IOException {
          ClassLoader var1 = getSystemClassLoader();
          return var1 == null ? getBootstrapResources(var0) : var1.getResources(var0);
      }
  
      private static URL getBootstrapResource(String var0) {
          URLClassPath var1 = getBootstrapClassPath();
          Resource var2 = var1.getResource(var0);
          return var2 != null ? var2.getURL() : null;
      }
  
      private static Enumeration<URL> getBootstrapResources(String var0) throws IOException {
          final Enumeration var1 = getBootstrapClassPath().getResources(var0);
          return new Enumeration<URL>() {
              public URL nextElement() {
                  return ((Resource)var1.nextElement()).getURL();
              }
  
              public boolean hasMoreElements() {
                  return var1.hasMoreElements();
              }
          };
      }
  
      static URLClassPath getBootstrapClassPath() {
          return Launcher.getBootstrapClassPath();
      }
  
      public InputStream getResourceAsStream(String var1) {
          URL var2 = this.getResource(var1);
  
          try {
              return var2 != null ? var2.openStream() : null;
          } catch (IOException var4) {
              return null;
          }
      }
  
      public static InputStream getSystemResourceAsStream(String var0) {
          URL var1 = getSystemResource(var0);
  
          try {
              return var1 != null ? var1.openStream() : null;
          } catch (IOException var3) {
              return null;
          }
      }
  
      @CallerSensitive
      public final ClassLoader getParent() {
          if (this.parent == null) {
              return null;
          } else {
              SecurityManager var1 = System.getSecurityManager();
              if (var1 != null) {
                  checkClassLoaderPermission(this.parent, Reflection.getCallerClass());
              }
  
              return this.parent;
          }
      }
  
      @CallerSensitive
      public static ClassLoader getSystemClassLoader() {
          initSystemClassLoader();
          if (scl == null) {
              return null;
          } else {
              SecurityManager var0 = System.getSecurityManager();
              if (var0 != null) {
                  checkClassLoaderPermission(scl, Reflection.getCallerClass());
              }
  
              return scl;
          }
      }
  
      private static synchronized void initSystemClassLoader() {
          if (!sclSet) {
              if (scl != null) {
                  throw new IllegalStateException("recursive invocation");
              }
  
              Launcher var0 = Launcher.getLauncher();
              if (var0 != null) {
                  Throwable var1 = null;
                  scl = var0.getClassLoader();
  
                  try {
                      scl = (ClassLoader)AccessController.doPrivileged(new SystemClassLoaderAction(scl));
                  } catch (PrivilegedActionException var3) {
                      var1 = var3.getCause();
                      if (var1 instanceof InvocationTargetException) {
                          var1 = var1.getCause();
                      }
                  }
  
                  if (var1 != null) {
                      if (var1 instanceof Error) {
                          throw (Error)var1;
                      }
  
                      throw new Error(var1);
                  }
              }
  
              sclSet = true;
          }
  
      }
  
      boolean isAncestor(ClassLoader var1) {
          ClassLoader var2 = this;
  
          do {
              var2 = var2.parent;
              if (var1 == var2) {
                  return true;
              }
          } while(var2 != null);
  
          return false;
      }
  
      private static boolean needsClassLoaderPermissionCheck(ClassLoader var0, ClassLoader var1) {
          if (var0 == var1) {
              return false;
          } else if (var0 == null) {
              return false;
          } else {
              return !var1.isAncestor(var0);
          }
      }
  
      static ClassLoader getClassLoader(Class<?> var0) {
          return var0 == null ? null : var0.getClassLoader0();
      }
  
      static void checkClassLoaderPermission(ClassLoader var0, Class<?> var1) {
          SecurityManager var2 = System.getSecurityManager();
          if (var2 != null) {
              ClassLoader var3 = getClassLoader(var1);
              if (needsClassLoaderPermissionCheck(var3, var0)) {
                  var2.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
              }
          }
  
      }
  
      protected Package definePackage(String var1, String var2, String var3, String var4, String var5, String var6, String var7, URL var8) throws IllegalArgumentException {
          synchronized(this.packages) {
              Package var10 = this.getPackage(var1);
              if (var10 != null) {
                  throw new IllegalArgumentException(var1);
              } else {
                  var10 = new Package(var1, var2, var3, var4, var5, var6, var7, var8, this);
                  this.packages.put(var1, var10);
                  return var10;
              }
          }
      }
  
      protected Package getPackage(String var1) {
          Package var2;
          synchronized(this.packages) {
              var2 = (Package)this.packages.get(var1);
          }
  
          if (var2 == null) {
              if (this.parent != null) {
                  var2 = this.parent.getPackage(var1);
              } else {
                  var2 = Package.getSystemPackage(var1);
              }
  
              if (var2 != null) {
                  synchronized(this.packages) {
                      Package var4 = (Package)this.packages.get(var1);
                      if (var4 == null) {
                          this.packages.put(var1, var2);
                      } else {
                          var2 = var4;
                      }
                  }
              }
          }
  
          return var2;
      }
  
      protected Package[] getPackages() {
          HashMap var1;
          synchronized(this.packages) {
              var1 = new HashMap(this.packages);
          }
  
          Package[] var2;
          if (this.parent != null) {
              var2 = this.parent.getPackages();
          } else {
              var2 = Package.getSystemPackages();
          }
  
          if (var2 != null) {
              for(int var3 = 0; var3 < var2.length; ++var3) {
                  String var4 = var2[var3].getName();
                  if (var1.get(var4) == null) {
                      var1.put(var4, var2[var3]);
                  }
              }
          }
  
          return (Package[])var1.values().toArray(new Package[var1.size()]);
      }
  
      protected String findLibrary(String var1) {
          return null;
      }
  
      private static String[] initializePath(String var0) {
          String var1 = System.getProperty(var0, "");
          String var2 = File.pathSeparator;
          int var3 = var1.length();
          int var4 = var1.indexOf(var2);
  
          int var6;
          for(var6 = 0; var4 >= 0; var4 = var1.indexOf(var2, var4 + 1)) {
              ++var6;
          }
  
          String[] var7 = new String[var6 + 1];
          var4 = 0;
          var6 = 0;
  
          for(int var5 = var1.indexOf(var2); var5 >= 0; var5 = var1.indexOf(var2, var4)) {
              if (var5 - var4 > 0) {
                  var7[var6++] = var1.substring(var4, var5);
              } else if (var5 - var4 == 0) {
                  var7[var6++] = ".";
              }
  
              var4 = var5 + 1;
          }
  
          var7[var6] = var1.substring(var4, var3);
          return var7;
      }
  
      static void loadLibrary(Class<?> var0, String var1, boolean var2) {
          ClassLoader var3 = var0 == null ? null : var0.getClassLoader();
          if (sys_paths == null) {
              usr_paths = initializePath("java.library.path");
              sys_paths = initializePath("sun.boot.library.path");
          }
  
          if (var2) {
              if (!loadLibrary0(var0, new File(var1))) {
                  throw new UnsatisfiedLinkError("Can't load library: " + var1);
              }
          } else {
              File var5;
              if (var3 != null) {
                  String var4 = var3.findLibrary(var1);
                  if (var4 != null) {
                      var5 = new File(var4);
                      if (!var5.isAbsolute()) {
                          throw new UnsatisfiedLinkError("ClassLoader.findLibrary failed to return an absolute path: " + var4);
                      }
  
                      if (loadLibrary0(var0, var5)) {
                          return;
                      }
  
                      throw new UnsatisfiedLinkError("Can't load " + var4);
                  }
              }
  
              int var6;
              for(var6 = 0; var6 < sys_paths.length; ++var6) {
                  var5 = new File(sys_paths[var6], System.mapLibraryName(var1));
                  if (loadLibrary0(var0, var5)) {
                      return;
                  }
  
                  var5 = ClassLoaderHelper.mapAlternativeName(var5);
                  if (var5 != null && loadLibrary0(var0, var5)) {
                      return;
                  }
              }
  
              if (var3 != null) {
                  for(var6 = 0; var6 < usr_paths.length; ++var6) {
                      var5 = new File(usr_paths[var6], System.mapLibraryName(var1));
                      if (loadLibrary0(var0, var5)) {
                          return;
                      }
  
                      var5 = ClassLoaderHelper.mapAlternativeName(var5);
                      if (var5 != null && loadLibrary0(var0, var5)) {
                          return;
                      }
                  }
              }
  
              throw new UnsatisfiedLinkError("no " + var1 + " in java.library.path");
          }
      }
  
      private static native String findBuiltinLib(String var0);
  
      private static boolean loadLibrary0(Class<?> var0, final File var1) {
          String var2 = findBuiltinLib(var1.getName());
          boolean var3 = var2 != null;
          if (!var3) {
              boolean var4 = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                  public Object run() {
                      return var1.exists() ? Boolean.TRUE : null;
                  }
              }) != null;
              if (!var4) {
                  return false;
              }
  
              try {
                  var2 = var1.getCanonicalPath();
              } catch (IOException var20) {
                  return false;
              }
          }
  
          ClassLoader var23 = var0 == null ? null : var0.getClassLoader();
          Vector var5 = var23 != null ? var23.nativeLibraries : systemNativeLibraries;
          synchronized(var5) {
              int var7 = var5.size();
  
              for(int var8 = 0; var8 < var7; ++var8) {
                  ClassLoader.NativeLibrary var9 = (ClassLoader.NativeLibrary)var5.elementAt(var8);
                  if (var2.equals(var9.name)) {
                      return true;
                  }
              }
  
              boolean var10000;
              synchronized(loadedLibraryNames) {
                  if (loadedLibraryNames.contains(var2)) {
                      throw new UnsatisfiedLinkError("Native Library " + var2 + " already loaded in another classloader");
                  }
  
                  int var24 = nativeLibraryContext.size();
  
                  for(int var10 = 0; var10 < var24; ++var10) {
                      ClassLoader.NativeLibrary var11 = (ClassLoader.NativeLibrary)nativeLibraryContext.elementAt(var10);
                      if (var2.equals(var11.name)) {
                          if (var23 == var11.fromClass.getClassLoader()) {
                              var10000 = true;
                              return var10000;
                          }
  
                          throw new UnsatisfiedLinkError("Native Library " + var2 + " is being loaded in another classloader");
                      }
                  }
  
                  ClassLoader.NativeLibrary var25 = new ClassLoader.NativeLibrary(var0, var2, var3);
                  nativeLibraryContext.push(var25);
  
                  try {
                      var25.load(var2, var3);
                  } finally {
                      nativeLibraryContext.pop();
                  }
  
                  if (!var25.loaded) {
                      var10000 = false;
                      return var10000;
                  }
  
                  loadedLibraryNames.addElement(var2);
                  var5.addElement(var25);
                  var10000 = true;
              }
  
              return var10000;
          }
      }
  
      static long findNative(ClassLoader var0, String var1) {
          Vector var2 = var0 != null ? var0.nativeLibraries : systemNativeLibraries;
          synchronized(var2) {
              int var4 = var2.size();
  
              for(int var5 = 0; var5 < var4; ++var5) {
                  ClassLoader.NativeLibrary var6 = (ClassLoader.NativeLibrary)var2.elementAt(var5);
                  long var7 = var6.find(var1);
                  if (var7 != 0L) {
                      return var7;
                  }
              }
  
              return 0L;
          }
      }
  
      public void setDefaultAssertionStatus(boolean var1) {
          synchronized(this.assertionLock) {
              if (this.classAssertionStatus == null) {
                  this.initializeJavaAssertionMaps();
              }
  
              this.defaultAssertionStatus = var1;
          }
      }
  
      public void setPackageAssertionStatus(String var1, boolean var2) {
          synchronized(this.assertionLock) {
              if (this.packageAssertionStatus == null) {
                  this.initializeJavaAssertionMaps();
              }
  
              this.packageAssertionStatus.put(var1, var2);
          }
      }
  
      public void setClassAssertionStatus(String var1, boolean var2) {
          synchronized(this.assertionLock) {
              if (this.classAssertionStatus == null) {
                  this.initializeJavaAssertionMaps();
              }
  
              this.classAssertionStatus.put(var1, var2);
          }
      }
  
      public void clearAssertionStatus() {
          synchronized(this.assertionLock) {
              this.classAssertionStatus = new HashMap();
              this.packageAssertionStatus = new HashMap();
              this.defaultAssertionStatus = false;
          }
      }
  
      boolean desiredAssertionStatus(String var1) {
          synchronized(this.assertionLock) {
              Boolean var3 = (Boolean)this.classAssertionStatus.get(var1);
              if (var3 != null) {
                  return var3;
              } else {
                  int var4 = var1.lastIndexOf(".");
                  if (var4 < 0) {
                      var3 = (Boolean)this.packageAssertionStatus.get((Object)null);
                      if (var3 != null) {
                          return var3;
                      }
                  }
  
                  while(var4 > 0) {
                      var1 = var1.substring(0, var4);
                      var3 = (Boolean)this.packageAssertionStatus.get(var1);
                      if (var3 != null) {
                          return var3;
                      }
  
                      var4 = var1.lastIndexOf(".", var4 - 1);
                  }
  
                  return this.defaultAssertionStatus;
              }
          }
      }
  
      private void initializeJavaAssertionMaps() {
          this.classAssertionStatus = new HashMap();
          this.packageAssertionStatus = new HashMap();
          AssertionStatusDirectives var1 = retrieveDirectives();
  
          int var2;
          for(var2 = 0; var2 < var1.classes.length; ++var2) {
              this.classAssertionStatus.put(var1.classes[var2], var1.classEnabled[var2]);
          }
  
          for(var2 = 0; var2 < var1.packages.length; ++var2) {
              this.packageAssertionStatus.put(var1.packages[var2], var1.packageEnabled[var2]);
          }
  
          this.defaultAssertionStatus = var1.deflt;
      }
  
      private static native AssertionStatusDirectives retrieveDirectives();
  
      static {
          registerNatives();
          nocerts = new Certificate[0];
          loadedLibraryNames = new Vector();
          systemNativeLibraries = new Vector();
          nativeLibraryContext = new Stack();
      }
  
      static class NativeLibrary {
          long handle;
          private int jniVersion;
          private final Class<?> fromClass;
          String name;
          boolean isBuiltin;
          boolean loaded;
  
          native void load(String var1, boolean var2);
  
          native long find(String var1);
  
          native void unload(String var1, boolean var2);
  
          public NativeLibrary(Class<?> var1, String var2, boolean var3) {
              this.name = var2;
              this.fromClass = var1;
              this.isBuiltin = var3;
          }
  
          protected void finalize() {
              synchronized(ClassLoader.loadedLibraryNames) {
                  if (this.fromClass.getClassLoader() != null && this.loaded) {
                      int var2 = ClassLoader.loadedLibraryNames.size();
  
                      for(int var3 = 0; var3 < var2; ++var3) {
                          if (this.name.equals(ClassLoader.loadedLibraryNames.elementAt(var3))) {
                              ClassLoader.loadedLibraryNames.removeElementAt(var3);
                              break;
                          }
                      }
  
                      ClassLoader.nativeLibraryContext.push(this);
  
                      try {
                          this.unload(this.name, this.isBuiltin);
                      } finally {
                          ClassLoader.nativeLibraryContext.pop();
                      }
                  }
  
              }
          }
  
          static Class<?> getFromClass() {
              return ((ClassLoader.NativeLibrary)ClassLoader.nativeLibraryContext.peek()).fromClass;
          }
      }
  
      private static class ParallelLoaders {
          private static final Set<Class<? extends ClassLoader>> loaderTypes = Collections.newSetFromMap(new WeakHashMap());
  
          private ParallelLoaders() {
          }
  
          static boolean register(Class<? extends ClassLoader> var0) {
              synchronized(loaderTypes) {
                  if (loaderTypes.contains(var0.getSuperclass())) {
                      loaderTypes.add(var0);
                      return true;
                  } else {
                      return false;
                  }
              }
          }
  
          static boolean isRegistered(Class<? extends ClassLoader> var0) {
              synchronized(loaderTypes) {
                  return loaderTypes.contains(var0);
              }
          }
  
          static {
              synchronized(loaderTypes) {
                  loaderTypes.add(ClassLoader.class);
              }
          }
      }
  }
  
  

  Read All

  ---

• Java基础(1)-ThreadLocal原理

  2019-03-12

  roboslyq

  Java基础

  Java基础  ThreadLocal
  • 1.ThreadLocal简介
  • 2. 代码演示
  • 3. Set过程
  • 4. get过程
  • 5.数据结构

  1.ThreadLocal简介

  ThreadLocal是从JDK1.2就开始有的一个类。在源码注释中有下面一段话：

  this class provides thread-local variables.  These variables differ from
  their normal counterparts in that each thread that accesses one (via its
  {@code get} or {@code set} method) has its own, independently initialized
  copy of the variable.  {@code ThreadLocal} instances are typically private
  static fields in classes that wish to associate state with a thread (e.g.,
  a user ID or Transaction ID).
  

  简单翻译过来有以下几点：

  • 这个类提供了线程局部(变量)，线程局部变量可以理解为线程 +局部 这两部分。首先是线程，这个变量有有效范围是线程，即不同线程间可以共享。其次是局部，即相对线程来说是局部的，即不同线程间变量是安全。
  • 在同一线程中，任何地方的方法调用可以方便的获取当前线程保存在ThreadLocal中的值。而不用通过函数传参。
  • 每个线程都保持对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

  2. 代码演示

  package com.roboslyq.jdk.lang;
  public class ThreadLocalTest {
     private final static ThreadLocal<String> THREAD_LOCAL_1 = new ThreadLocal<String>();
     private final static ThreadLocal<String> THREAD_LOCAL_2 = new ThreadLocal<String>();
      public static void main(String[] args) throws InterruptedException {
          //模拟不同的线程赋值和取值
          for(int i=0;i<2;i++){
              new Thread(
                      new Runnable() {
                          public void run() {
                              ThreadLocalTest.getThreadLocal1().set("currentThead -- 								THREAD_LOCAL_1 -- " + Thread.currentThread().getId());
                              ThreadLocalTest.getThreadLocal2().set("currentThead -- 								THREAD_LOCAL_2 -- " + Thread.currentThread().getName());
                              Print print = new Print();
                              print.print();
                          }
                      }
              ).start();
          }
          //等待1秒，让线程在控制台完成打印
          Thread.sleep(1000);
      }
      public static ThreadLocal<String> getThreadLocal1() {
          return THREAD_LOCAL_1;
      }
      public static ThreadLocal<String> getThreadLocal2() {
          return THREAD_LOCAL_2;
      }
  }
  //单独一个类，模拟取值
  class Print{
      //从ThreadLocal载体(ThreadLocalTest)中，获取对应的ThreadLocal保持的值
      public void print(){
          System.out.println(ThreadLocalTest.getThreadLocal1().get());
          System.out.println(ThreadLocalTest.getThreadLocal2().get());
      }
  }
  

  打印日志

  currentThead -- THREAD_LOCAL_1 -- 11
  currentThead -- THREAD_LOCAL_2 -- Thread-0
  currentThead -- THREAD_LOCAL_1 -- 12
  currentThead -- THREAD_LOCAL_2 -- Thread-1
  Process finished with exit code 0
  

  3. Set过程

  

  1. 调用ThreadLocal.set(T value)方法，在方法内部通过Thread.currentThread获取到当前线程的引用。 2. 通过当前线程(Current Thread)来获取线程中保存的ThreadLocalMaps引用，然后从ThreadLocalMaps中以ThreadLocal为Key获取具体的ThreadLocalMap。如果是首次调，则获取到的ThreadLocalMap为Null,此时调用createMap(t, value)创建一个新的对象。如果不是第一次，则ThreadLocalMap不为空，直接保存即可。

  4. get过程

  

  1. 调用ThreadLocal.set(T value)方法，在方法内部通过Thread.currentThread获取到当前线程的引用。
  2. 通过当前线程(Current Thread)来获取线程中保存的ThreadLocalMaps引用，然后从ThreadLocalMaps中以ThreadLocal为Key获取具体的ThreadLocalMap。如果是首次调，则获取到的ThreadLocalMap为Null。如果已经正常赋值，则ThreadLocalMap不为空，直接获取返回值即可。

  5.数据结构

  

  Read All

  ---