YumaoZzz

java visualVM 以及其他jvm性能监控工具使用

2017-12-11T00:00:00+00:00

关于visualVM以及其他jvm性能监控工具使用的一些使用记录

visualVM远程连接jvm

添加JMX连接
关于jmx：JMX的全称为Java Management Extensions.
顾名思义，是管理Java的一种扩展。这种机制可以方便的管理、监控正在运行中的Java程序。常用于管理线程，内存，日志Level，服务重启，系统环境等
1：确保jvm启动时的参数
```
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=xxxx <- jmx连接时的端口
-Dcom.sun.management.jmxremote.ssl=false <- ssl安全连接,默认为是
-Dcom.sun.management.jmxremote.authenticate=false <- 不需要认证
```
2：使用visualvm连接
先建立对应的远程连接，之后添加JMX连接

添加jstatd连接 1：修改$JAVA_HOME/jre/lib/security/java.policy中，在最后一行添加

permission java.security.AllPermission;

2：启动jstatd服务

jstatd -J-Djava.security.policy=jstatd.all.policy -J-Djava.rmi.server.logCalls=true -J-Djava.rmi.server.hostname=139.199.182.196

3：添加jstatd连接，visualVM会自动连接

jconsole

查询jvm的cpu&内存
需要jvm启动时加入命令

-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=xxxx <- jmx连接时的端口
-Dcom.sun.management.jmxremote.ssl=false <- ssl安全连接,默认为是
-Dcom.sun.management.jmxremote.authenticate=false <- 不需要认证

jstat

从左到右代表值：
第一个sur的容量，第二个sur的容量，第一个sur已使用空间，第二个sur已使用空间
eden容量，eden已使用空间，old代容量，old代已使用空间
方法区大小，方法区使用大小，压缩类空间大小，压缩类空间似乎用大小
年轻代gc次数，年轻代gc时间，old代gc次数，old代gc时间，gc总时间

jmap

jstack

实例:发现某个进程cpu过高,想找到对应的线程,打印线程栈 1：先查找对应的进程top 1：再通过top查找对应的线程top -H -p pid 2：通过jstack打印对应线程栈信息jstack pid 遇到的问题:

10555: Unable to open socket file: target process not responding or HotSpot VM not loaded
The -F option can be used when the target process is not responding

Spring NoSQL

2017-11-27T00:00:00+00:00

Spring NoSQL 关于spring data mongodb/redis的基础使用

简介

文档数据库
适合做：数据不需要分散到多个表or实体中，将信息收集到非规范化的结构更有意义；文档是独立的实体
eg：学生成绩单，不同学生相互独立，其相互的成绩也没有必要关联
不适合做：具有明显关联关系的数据

使用mongodb

spring data mongodb提供了三种方式在spring中使用mongodb
通过注解实现对象-文档映射；
使用MongoTemplate实现基于模板的数据库访问；
自动化的运行时Repository生成功能。

启用mongodb
``` 编写mongodb配置类 @Configuration @EnableMongoRepositories( basePackages = “spitter.db” ) /**
MongoTemplate:数据库与代码之间的接口，所有操作在这里面
通过继承AbstractMongoConfiguration，其回隐式的创建MongoTemplate */ public class MongoConfig{ @Bean public MongoClientFactoryBean mongoClientFactoryBean(){ MongoClientFactoryBean mongoClientFactoryBean = new MongoClientFactoryBean(); mongoClientFactoryBean.setHost(“localhost”); return mongoClientFactoryBean; } @Bean public MongoOperations mongoTemplate(Mongo mongo){ return new MongoTemplate(mongo, “OrdersDB”); } } ```
为模型添加注解，持久化文档 ``` /**
Document：借助MongoTemplate自动生成Repository持久化 * */ @Document public class Order implements Serializable{ @Field(value = “username”) private String username; @PersistenceConstructor public Order(String username, String id) { this.username = username; this.id = id; } @Id private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } } ```

使用Mongotemplate访问

@Repository
public class OrderRepository {
  @Autowired
  private MongoOperations template;
  public List<Order> getOrders(){
      int id = (new Random().nextInt(11000));
      template.save(new Order("mike", String.valueOf(id)));
      return template.findAll(Order.class);
  }
}

注：
1：遇到问题，spring data mongodb与spring的版本兼容问题
2：还需要引入mongo-java-driver

使用redis操作key-value数据

提供了4种客户端连接工厂
JedisConnectionFactory
JredisConnectionFactory
LettuceConnectionFactory
SrpConnectionFactory

连接redis

  @Bean
  public JedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig){
      JedisConnectionFactory jf = new JedisConnectionFactory();
      jf.setPoolConfig(jedisPoolConfig);
      jf.setHostName("localhost");
      jf.setPort(6379);
      jf.afterPropertiesSet();
      return jf;
  }

使用redisTemplate
提供了两个模板
RedisTemplate
StringRedisTemplate

  @Bean
  public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory){
      RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      redisTemplate.afterPropertiesSet();
      return redisTemplate;
  }

使用key value序列器
stringRedisTemplate默认使用String序列化策略 redisTemplate默认使用JdkSerializationRedisSerializer序列化策略
指定序列化策略：

默认提供的序列化策略：
GenericToStringSerializer：使用Spring转换服务进行序列化；
JacksonJsonRedisSerializer：使用Jackson 1，将对象序列化为JSON；
Jackson2JsonRedisSerializer：使用Jackson 2，将对象序列化为JSON；
JdkSerializationRedisSerializer：使用Java序列化；
OxmSerializer：使用Spring O/X映射的编排器和解排器（marshaler和unmarshaler）实现序列化，用于XML序列化；
StringRedisSerializer：序列化String类型的key和value。
  @Bean
  public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory){
      RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      redisTemplate.setKeySerializer(new StringRedisSerializer());
      redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Order>(Order.class));
      redisTemplate.afterPropertiesSet();
      return redisTemplate;
  }

否则如果使用默认的redisTemplate可能会乱码

Spring 缓存

2017-11-22T00:00:00+00:00

Spring缓存 spring都有哪几种方式能实现缓存？为什么以及什么情况下需要用到、更新、删除缓存

启用支持

1：注解驱动的缓存 @Cacheable @CacheEvict
2：xml声明的缓存
如果使用java配置，需要在其中一个配置类上添加@EnableCaching

@EnableCaching
@Configuration
public class CacheConfig {
    @Bean
    // 声明缓存管理器
    public CacheManager cacheManager(){
        return new ConcurrentMapCacheManager();
    }
}

如果使用xml配置 (启用缓存)
本质上，都是创建一个切面并触发spring缓存注解的切点。根据所使用的注解以及缓存状态，这个切面会从缓存获取数据，将数据添加到缓存或从缓存中移除
ConcurrentMapCacheManager这个简单的缓存管理器使用java.util.concurrent.ConcurrentHashMap作为缓存存储（测试，基于内存）

配置缓存管理器
SimpleCacheManager
NoOpCacheManager
ConcurrentMapCacheManager
CompositeCacheManager
EhCacheCacheManager
RedisCacheManager（来自于Spring Data Redis项目）
GemfireCacheManager（来自于Spring Data GemFire项目）

1：使用ehcache

EhcacheConfig.class
    /**
     * 声明一个CacheManager bean
     * Spring提供了EhCacheManager-FactoryBean来生成EhCache的CacheManager
     *
     */
    @Bean
    public EhCacheManagerFactoryBean ehcache(){
        EhCacheManagerFactoryBean eb = new EhCacheManagerFactoryBean();
        eb.setConfigLocation(new ClassPathResource("spittr/cache/ehcache.xml"));
        return eb;
    }
    /**
     * 注：
     * org.springframework.cache.ehcache
     * 需要导入spring-context-support，且还需要额外导入net.sf.ehcache
     * 通过传入EhcacheCacheManager实例实现
     * EhCache的CacheManager要被注入到Spring的EhCacheCacheManager
     *
     */
    @Bean
    public EhCacheCacheManager cacheManager(CacheManager cm){
        return new EhCacheCacheManager(cm);
    }
ehcache.xml:
<ehcache>
    <cache name="spittleCache" maxBytesLocalHeap="50m" timeToLiveSeconds="100"/>
</ehcache>

2:使用redis缓存
如果缓存的条目是键值对形式的，那非常适合用redis存储

需要引入org.springframework.data.reids & redis.client
redis提供了RedisCacheManager，是CacheManager的实现，会与redis服务器协作，通过RedisTemplate将缓存条目存储到Redis中
    @Bean
    public JedisPoolConfig jedisPoolConfig(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxWaitMillis(1000);
        return jedisPoolConfig;
    }
    @Bean
    public JedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig){
        JedisConnectionFactory jf = new JedisConnectionFactory();
        jf.setPoolConfig(jedisPoolConfig);
        jf.setHostName("localhost");
        jf.setPort(6379);
        jf.afterPropertiesSet();
        return jf;
    }
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate){
        return new RedisCacheManager(redisTemplate);
    }
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
注：报错// DefaultSerializer requires a Serializable payload but received an object of type [spitter.Spittle]
对应类必须实现Serializable

为方法添加注解支持缓存

@Cacheable 表明Spring在调用方法之前，首先应该在缓存中查找方法的返回值。如果这个值能够找到，就会返回缓存的值。否则的话，这个方法就会被调用，返回值会放到缓存之中
@CachePut 表明Spring应该将方法的返回值放到缓存中。在方法的调用前并不会检查缓存，方法始终都会被调用
@CacheEvict 表明Spring应该在缓存中清除一个或多个条目
@Caching 这是一个分组的注解，能够同时应用多个其他的缓存注解

填充缓存

    /**
    * 缓存切面会拦截调用并在缓存中查找之前以名spittleCache存储的返回值
    * 缓存的key是传递到findOne()方法中的id参数
    * 如果按照这个key能够找到值的话，就会返回找到的值，方法不会再被调用
    * 但是这样仅限于这个实现类，为了避免出现这个问题，可以将Cacheable声明在接口方法上
    * 带有@CachePut的方法始终会被调用，可以实现预加载
    * 例如，可以在save(Spittle spittle)方法上添加@CachePut("spittleCache")
    * 但是这样回导致key为Spittle，所以需要指定key
    * @CachePut("spittleCache", key="#result.id") <= 表达式#result能够得到返回的Spittle
    * 此外，还有当数据有修改时，可以通过CachePut强制更新
    */
    @Cacheable("spittleCache")
    public Spittle findSpittels(int id) {
        System.out.println("调用一次:" + id);
        return jdbc.queryForObject("select message, created_at, longitude,latitude from Spittle where id = ?",
                new SpitterRowMapper(),
                id);
    }
注：这里遇到一个问题，1.7.0的spring-data-redis返回RedisCacheManager对象，其父类没有实现CacheManager接口，是因为没有spring-support的jar或者对应jar的版本与spring版本不匹配

条件化缓存
某些情况下，可能只有符合某些条件下我们才会使用缓存

    /**
    * unless:如果为true,阻止将对象放入缓存，但是如果缓存中存在，依然从缓存中读取
    * condition:如果condition返回false,禁用缓存
    */
    @CachePut(value = "spitterCache", key = "#result.username", unless = "#result.username.contains('NoCache')")

Spring 持久化数据

2017-11-16T00:00:00+00:00

Spring的持久化数据 spring中持久化数据的方式很多，本文主要介绍几种配置datasource的方法，以及如何通过spring内置的jdbc模板实现数据的持久化

配置数据源：

通过JDBC驱动程序定义的数据源；
通过JNDI查找的数据源；
连接池的数据源；

JNDI：
这种配置的好处在于数据源完全可以在应用程序之外进行管理，这样应用程序只需在访问数据库的时候查找数据源就可以了。另外，在应用服务器中管理的数据源通常以池的方式组织，从而具备更好的性能，并且还支持系统管理员对其进行热切换通过装配 ```

- 连接池：<br>
开源库：Apache Commons DBCP、c3p0、BoneCP

- 基于JDBC驱动的数据源：<br>
spring提供了3个数据源类
DriverManagerDataSource（在每个连接请求时都会返回一个新建的连接）、SimpleDriverDataSource、SingleConnectionDataSource（在每个连接请求时都会返回同一个的连接）

- 使用嵌入式的数据源：<br>
优势（在每次启动服务时，都能重新填充数据）

<jdbc:embedded-database id="dataSourceEm" type="H2">
    <jdbc:script location="schema.sql"/>
</jdbc:embedded-database> ``` - 通过profile选择数据源<br> 只要在配置bean前，添加<beans profile="dev">即可

在spring中使用jdbc

平时在使用jdbc最容易出现的问题：1.代码混乱且很多冗余；2.异常情况无法处理；解决方法：使用jdbc模板

使用jdbc模板
Spring为JDBC提供了三个模板类供选择
JdbcTemplate（被废弃）：最基本的Spring JDBC模板，这个模板支持简单的JDBC数据库访问功能以及基于索引参数的查询
NamedParameterJdbcTemplate：使用该模板类执行查询时可以将值以命名参数的形式绑定到SQL中，而不是使用简单的索引参数
SimpleJdbcTemplate：该模板类利用Java 5的一些特性如自动装箱、泛型以及可变参数列表来简化JDBC模板的使用

@Bean
public JdbcTemplate jdbcTemplate(DataSource datasource){
  return new JdbcTemplate(datasource);
}

如果通过jdbcTemplate查找数据，则需要将结果映射到对象中

return jdbc.queryForObject(select_by_id, new SpitterRowMapper(), id);
private static final class SpitterRowMapper implements RowMapper<Spitter>{
  public Spiter mapRow(ResultSet rs, int rowNum){
      return new Spitter(rs.getLong("id"), ....)
  }
}
其中queryForObject有三个参数
String对象，包含了要从数据库中查找数据的SQL
RowMapper对象，用来从ResultSet中提取数据并构建域对象
可变参数列表，列出了要绑定到查询上的索引参数值
对于查询返回的每一行数据，JdbcTemplate将会调用RowMapper的mapRow()方法，并传入一个ResultSet和包含行号的整数。在SpitterRowMapper的mapRow()方法中，我们创建了Spitter对象并将ResultSet中的值填充进去
还可以通过方法引用、匿名函数的方法处理queryForObject

使用命名参数
以往插入数据时可能是这样

jdbc.update("insert into xx (a,b) values (?,?)", s.getxx(), s.getxx())

这样可能会导致如果参数顺序有变化，那么还需要修改从参数值的顺序
通过命名参数可以避免这种问题

jdbc.update("insert into xx (id,name) values (:id, :name)", new HashMap(){put("name", s.getName());})
并且要将模板类改为NamedParameterJdbcTemplate

Spring web概述

2017-10-30T00:00:00+00:00

Spring web概述主要内容有：如何启动springweb；如何建立简单的控制器且返回视图；如何接收处理来自客户端的请求

关于流程

1.请求 -> spring前端控制器DispatcherServlet 2.DispatcherServlet -> 查询handlermapping -> controller(将请求发送给对应的控制器) 3.conroller -> 服务对象处理业务逻辑 4.服务对象产生信息模型(model) -> view -> DispatcherServlet -> 视图解析器view resolver匹配视图名为一个特定视图的实现(例如jsp) -> 浏览器

SpitterWebInit:
/**
 * 在servlet3.0下，容器回去类路径中查找实现javax.servlet.servletcontainerinitializer接口的类
 * spring提供实现这个接口的实现类：springservletcontainerinitializer，反查实现了webapplicationinitializer类将配置任务交给他们完成
 * spring引入了WebApplicationInitializer基础实现，也就是AbstractAnnotationConfigDispatcherServletInitializer
 * 所以只要我们实现了AbstractAnnotationConfigDispatcherServletInitializer，也就同时实现了WebApplicationInitializer
 * 当部署在servlet3.0容器中时，容器会自动发现它，配置servlet上下文
 */
// 扩展AbstractAnnotation-ConfigDispatcherServletInitializer的任意类都会自动地 配置Dispatcher-Servlet和Spring应用上下文，Spring的应用上下
// 文会位于应用程序的Servlet上下文之中
public class SpitterWebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }
    @Override
    // 指定配置类 bean
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }
    @Override
    // DispatcherServlet映射到"/"
    /**
     * DispatcherServlet 和 ContextLoaderListener(servlet监听器)
     * DispatcherServlet启动时 - 创建spring上下文，加载bean(getServletConfigClasses)
     * 还有一个上下文，由ContextLoaderListener创建，加载应用中其他bean(驱动应用后端中间层和数据层组件)
     * GetServlet-ConfigClasses()会返回带有@Configuration注解的类，定义DispatcherServlet应用上下文中的bean
     * getRootConfigClasses()方法返回的带有@Configuration注解的类将会用来配置ContextLoaderListener创建的应用上下文中的bean
     */
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}
WebConfig:
@Configuration
// 启用spring mvc
@EnableWebMvc
@ComponentScan(basePackages = {"spittr"})
public class WebConfig extends WebMvcConfigurationSupport{
    @Bean
    // 配置jsp视图解析器
    public ViewResolver viewResolver(){
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        resolver.setExposeContextBeansAsAttributes(true);
        return resolver;
    }
    @Override
    // 静态资源处理，将对静态资源的请求转发到servlet容器默认的servlet上，而不是使用DispatcherServlet
    protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}
RootConfig:
@Configuration
@ComponentScan(basePackages = {"spittr"}, excludeFilters = {@ComponentScan.Filter(type= FilterType.ANNOTATION, value= EnableWebMvc.class)})
public class RootConfig {
}

传递模型到视图中

DataConfig:
@Configuration
public class DataConfig {
  @Bean
  public DataSource dataSource(){
      return new EmbeddedDatabaseBuilder()
              .setType(EmbeddedDatabaseType.H2)
              .addScripts("schema.sql", "data.sql")
              .build();
  }
  @Bean
  public JdbcOperations jdbcTemplate(DataSource dataSource) {
      return new JdbcTemplate(dataSource);
  }
}
JDBCSpittleRepository:
@Repository
public class JDBCSpittleRepository implements SpittleRepository {
  @Autowired
  private JdbcOperations jdbc;
  public List<Spittle> getSpittles() {
      return jdbc.query("select * from Spittle", new SpittleRowMapper());
  }
  private static class SpittleRowMapper implements RowMapper<Spittle> {
      public Spittle mapRow(ResultSet rs, int rowNum) throws SQLException {
          return new Spittle(
                  rs.getLong("id"),
                  rs.getString("message"),
                  rs.getDate("created_at"),
                  rs.getDouble("longitude"),
                  rs.getDouble("latitude"));
      }
  }
}
Controller:
@Controller
@RequestMapping("/spittles")
public class SpittleController {
  @Autowired
  private SpittleRepository spittleRepository;
  @RequestMapping(method = RequestMethod.GET)
  public String spittles(Model model){
      model.addAttribute("spittleList", spittleRepository.getSpittles());
      return "spittles";
  }
}

注:@Repository：DAO组件类
需要通过maven导入h2，spring-jdbc的依赖

后端接受请求输入

springmvc接收的请求有
查询参数（Query Parameter）
表单参数（Form Parameter）
路径变量（Path Variable）

查询参数

  @RequestMapping(method = RequestMethod.GET)
  public List<Spittle> spittles(Model model, @RequestParam(defaultValue = MAX_LONG, value = "max") Long max){
      System.out.println(max);
      return spittleRepository.getSpittles();
  }

路径参数

  @RequestMapping(value = "/{id}", method = RequestMethod.GET)
  public String spittlesByPath(Model model, @PathVariable("id") Long id){
      System.out.println(id);
      model.addAttribute("spittleList", spittleRepository.getSpittles());
      return "spittles";
  }
  注：这里不能直接返回List<Spittle>,因为url最后一个是id,逻辑视图的名称将会根据请求路径推断得出

Spring MVC允许我们在@RequestMapping路径中添加占位符。占位符的名称要用大括号（“{”和“}”）括起来。路径中的其他部分要与所处理的请求完全匹配，但是占位符部分可以是任意的值

keywords:DispatcherServlet,@EnableWebMvc,ViewResolver,@Repository,@Controller,@RequestMapping,@RequestParam,@PathVariable,Model

处理表单

    @RequestMapping(value = "register", method = RequestMethod.POST)
    // 当处理注册表单的POST请求时，控制器需要接受表单数据并将表单数据保存为Spitter对象
    public String register(Spitter spitter){
        spitterRepository.save(spitter);
        // 当InternalResourceViewResolver看到视图格式中的“redirect:”前缀时，它就知道要将其解析为重定向的规则，而不是视图的名称
        return "redirect:/spitter/" + spitter.getUsername();
    }
    @RequestMapping(value = "/{username}", method = RequestMethod.GET)
    public String showSpitter(@PathVariable("username") String username, Model model){
        model.addAttribute(spitterRepository.findByUsername(username));
        return "profile";
    }
registerForm:
<form method="POST">
    First Name: <input type="text" name="firstName" /><br/>
    Last Name: <input type="text" name="lastName" /><br/>
    Email: <input type="email" name="email" /><br/>
    Username: <input type="text" name="username" /><br/>
    Password: <input type="password" name="password" /><br/>
    <input type="submit" value="Register" />
</form>

keywords:redirect:

Spring Aop切面

2017-10-30T00:00:00+00:00

Spring的Aop切面散布于应用中多处的功能被称为横切关注点，且从概念上与应用的业务逻辑分离，将横切关注点与业务逻辑分离就是面向切面编程要解决的问题

AOP概述

一个被划分为模块的应用如果要重用通用功能的话，最常见是继承或委托，然而两种方式都可能导致系统复杂化
切面提供了取代这些的另一种方案，更清晰简洁，通过声明的方式定义功能以何种方式在何处应用，无需修改受影响的类。横切关注点可以被模块化为特殊类，这些类就被称为切面。

术语
通知(advice)
AOP中，切面的工作称为通知，定义了切面是什么以及何时使用(调用前?调用后?抛出异常?)
分为:前置通知(before) 后置通知(after) 返回通知(after-returning) 异常通知(after-throwing) 环绕通知(around)
切点(pointcut)
一个切点不需要通知应用的所有连接点，切点有助于缩小切面所通知的连接点范围，通常使用明确类、方法，或者利用正则定义锁匹配的类、方法指定切点
连接点(join point)
连接点是应用执行过程中能够插入切面的一个点，可以是调用方法时，抛出异常，或者修改一个字段时；切面代码可以利用这些点插入到应用的正常流程，添加新行为
切面(aspect)
是通知和切点的结合，包括何时以及何处完成功能
引入(introduction)
引入允许我们向现有类添加新方法或属性，在不修改现有类的情况下，具有新行为和状态
织入(weaving)
是把切面应用到目标对象并创建新代理对象的过程；在目标对象生命周期里有多个点可以织入:编译期(需要特殊的编译器，Aspectj是已这种方式织入)、类加载期(需要特殊的类加载器，Aspectj支持这种方式织入)、运行期(Spring aop是已这种方式织入)
Spring对AOP支持
1.基于代理的经典Spring AOP
2.纯POJO切面
3.@AspectJ注解驱动的切面
4.注入式AspectJ切面（适用于Spring各版本）
关于Spring在运行时通知对象
spring只支持方法级别的连接点
keywords:通知,切点,连接点,切面,引入,织入

通过切点选择连接点

编写切点
```
package concert;
public interface Performance {
  public void perform();
}
```
使用AspectJ切点表达式表达式*开始表示不关心方法返回值，如果需要匹配切点仅匹配concert包，可使用within()指示器

切点中选择bean

执行beanPerformance.perform应用通知，但是bean id限定为woodstock
execution(* concert.Performance.perform() and bean('woodstock'))

使用注解创建切面

@Component
public class TestPerformance implements Performance{
    public void perform() {
        System.out.println("TestPerformance perform");
    }
}
// 通过@Aspect进行标注该类是一个切面(通知类)
// AspectJ提供了5个注解定义通知
// @After @AfterReturning @AfterThrowing @Around @Before
@Aspect
public class Audience {
	// 通过@Pointcut可以在切面内定义可重用的切点
    @Pointcut("execution(* demo.Performance.perform(..))")
    public void performance(){}
    @Before("performance()")
    public void silenceCellPhones(){
        System.out.println("silenceCellPhones");
    }
}

即使使用AspectJ注解，但是该类也不会被视为切面，所以需要启用AspectJ注解

javaconfig:
@Configuration
@ComponentScan
// 启用自动代理功能
@EnableAspectJAutoProxy
public class AopConfig {
	// 声明切面Bean
    @Bean
    public Audience audience(){
        return new Audience();
    }
}
xmlconfig:
<aop:aspectj-autoproxy/>
<bean class="concert.Audience"/>
``
遇到的问题:<br/>
1.AspectJ使用maven的artifactId应该是aspectjweaver<br/>
2.aspectjweaver的版本需要与当前使用jdk版本一致,即jdk1.8对应的版本号是1.8.x,否则报错<br/>

- 创建环绕通知<br/>

@Around("execution(* springdemo.CD.Performance.perform(..))")
// ProceedingJoinPoint这个对象是必须要有的，因为要在通知中通过它来调用被通知的方法
public void watchPerformance(ProceedingJoinPoint jp){
    try{
        System.out.println("before...");
        // 当要将控制权交给被通知的方法时，它需要调用ProceedingJoinPoint的proceed()方法
        // 如果不调用proceed方法，方法就会被阻塞
        jp.proceed();
        System.out.println("after...");
    }catch (Throwable e){
        System.out.println("Exception...");
    }
} ```

处理通知中的参数
如果被通知的方法时有参数的，并且这些参数需要关注，那么久切片就需要访问这些参数

@Aspect
public class TrackCounter {
  private Map<Integer, Integer> trackCounts = new HashMap<Integer, Integer>();
  // args表明传给getPlayCount的int参数也会传给通知
  @Pointcut("execution(* springdemo.CD.CompactDisc.playTrack(int)) && args(trackNumber)")
  public void trackPlayed(int trackNumber){}

  @Before("trackPlayed(trackNumber)")
  public void countTrack(int trackNumber){
      int currentCount = getPlayCount(trackNumber);
      currentCount ++;
      trackCounts.put(trackNumber, currentCount);
  }
  public int getPlayCount(int trackNumber){
      return trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
  }
}

通过注解引入新功能
由于java不是动态语言，所以不能像Python一样为对象或类动态添加方法，但是可以通过切片为spring bean添加新方法
相当于切片实现了包装bean相同接口的代理，如果代理能暴露新接口
```
接口
public interface Encoreable {
  void performEncore();
}
实现类
public class EncoreableImpl implements Encoreable {
  public void performEncore() {
      System.out.println("performEncore");
  }
}
切面
@Aspect
public class EncoreableConfig {
  // 通过@DeclareParents注解，将Encoreable接口引入到Performance bean中
  @DeclareParents(value="springdemo.CD.Performance+", defaultImpl = EncoreableImpl.class)
  public static Encoreable encoreable;
}
测试
@Test
public void testPerform(){
  ((Encoreable) performance).performEncore();
  performance.perform();
}
```
@DeclareParents注解由三部分组成： value属性指定了哪种类型的bean要引入该接口。在本例中，也就是所有实现Performance的类型。（标记符后面的加号表示是Performance的所有子类型，而不是Performance本身。）
defaultImpl属性指定了为引入功能提供实现的类。在这里，我们指定的是DefaultEncoreable提供实现。
@DeclareParents注解所标注的静态属性指明了要引入了接口。在这里，我们所引入的是Encoreable接口

keywords:@Aspect,execution,@After,@AfterReturning,@AfterThrowing,@Around,@Before,@Pointcut,@DeclareParents

在xml中声明切面

如果要声明切面，但是又不能为类添加注解时，必须转向xml配置配置方式:

<aop:advisor>定义AOP通知器
<aop:after>定义AOP后置通知（不管被通知的方法是否执行成功）
<aop:afterreturning>定义AOP返回通知
<aop:afterthrowing>定义AOP异常通知
<aop:around>定义AOP环绕通知
<aop:aspect>定义一个切面
<aop:aspectjautoproxy>启用@AspectJ注解驱动的切面
<aop:before>定义一个AOP前置通知
<aop:config>顶层的AOP配置元素。大多数的<aop:*>元素必须包含在<aop:config>元素内
<aop:declareparents>以透明的方式为被通知的对象引入额外的接口
<aop:pointcut>定义一个切点

    <bean id="audience" class="springdemo.CD.Audience"/>
    <bean id="testPerformance" class="springdemo.CD.TestPerformance"/>
    <aop:config>
        <aop:aspect ref="audience">
            <aop:pointcut id="perform" expression="execution(* demo.Performance.perform(..))"/>
            <!--<aop:before method="silenceCellPhones" pointcut-ref="perform"/>-->
            <!-- 环绕 -->
            <aop:around method="watchPerformance" pointcut-ref="perform"/>
            <!-- 为被通知类引入新功能 -->
            <aop:declare-parents types-matching="demo.Performance+" implement-interface="demo.Encoreable" default-impl="demo.DefaultEncoreable"/>
        </aop:aspect>
    </aop:config>

Spring装配bean

2017-10-29T00:00:00+00:00

Spring的Bean装配

自动装配

基于java的装配
@ComponentScan(basePackages = {"springdemo.CD"})
基于xml的配置
<context:component-scan/>

代码中的使用

@Component
public class CDPlayer implements MediaPlayer{
    private CompactDisc cd;
    @Autowired
    public CDPlayer(CompactDisc cd){
        this.cd = cd;
    }
    public void Play() {
        cd.play();
    }
}

// 自动创建spring应用上下文
@RunWith(SpringJUnit4ClassRunner.class)
// 通过CDPlayerConfig加载配置
@ContextConfiguration(classes = CDPlayerConfig.class)
public class CDPlayerTest {
    @Autowired
    private CompactDisc cd;
    @Autowired
    private MediaPlayer player;
    @Test
    public void cdShouldNotBeNull(){
        Assert.assertNotNull(cd);
    }
    @Test
    public void play(){
        player.Play();
    }
}

Keywords:@ComponentScan,,@Component,@Autowired

基于Java的装配

// Configuration注解表明这个类时一个配置类，包括spring上下文如何创建bean的细节
@Configuration
// 自动装配这个包下的类
// @ComponentScan(basePackages = {"springdemo.CD"})
// 但是如果涉及一些第三方包，我们无法通过隐式的方式加载，就必须要显式配置
// 通过将其他java配置导入
@Import(AnotherConfig.class)
// java配置中加载xml配置
@ImportResource("classpath:CDPlayerXmlTest-context.xml")
public class CDPlayerConfig {

    // 生命简单的bean，返回一个对象
    @Bean
    public CompactDisc sgtPeppers(){
        return new SgtPeppers();
    }
    // 如果这样写，那么每个CDPlayer构造时都要有一份独立的CompactDisc，这显然时没有必要的
    @Bean
    public CDPlayer anotherCdPlayers(){
        return new CDPlayer(sgtPeppers());
    }
    // 通过请求一个CompactDisc作为参数，自动装配一个CompactDisc到配置方法
    @Bean
    public CDPlayer cdPlayer(CompactDisc cd){
        // 这里也可以通过setter的方式
        // CDPlayer cd = new CDPlayer();
        // cd.setCompactDisc(cd);
        // return cd;
        return new CDPlayer(cd);
    }
}

keywords:@Configuration,@Import,@ImportResource,@Bean

通过xml装配

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--文件名称必须以-context.xml结尾-->
    <!--c- 开头 与<constructor-arg>功能一致-->
    <!--p- 开头与<property>功能一致-->
    <bean id="compactDisc" class="springdemo.CD.SgtPeppers" />
    <bean id="mediaPlayer" class="springdemo.CD.CDPlayer" c:cd-ref="compactDisc" />
    <!--导入其他的xmlconfg配置文件-->
    <import resource="AnotherXmlConfig-context.xml"/>
    <!--导入其他的javaconfig配置文件-->
    <bean class="springdemo.CD.AnotherConfig"/>
    <!--不管使用javaconfig或xmlconfig，一般都会创建一个根配置，这个配置将更多的装配类或xml文件组装起来-->
    <!--并且在跟配置启用组件扫描-->
</beans>

环境profile

主要是为了生产环境/测试环境/开发环境中不同环境的bean装配(条件装配的一种)

// 可以在类加注解
// @Profile("dev")
public class DevelopmentProfileConfig {
    @Bean(destroyMethod = "shutdown")
    @Profile("dev")
    public DataSource dataSource(){
        return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2)
                .addScript("classpath:schema.sql").build();
    }
}

激活Profile

正式的web項目中，可以在web.xml中添加
  <context-param>
    <param-name>spring.profiles.default</param-name>
    <param-value>dev</param-value>
  </context-param>
测试项目中，可以
@ActiveProfile("dev")
public class CDPlayerConfig {}

keywords:@Profile,@ActiveProfile

条件化装配bean

首先要定义类实现接口Condition

public class MagicExistsCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment env = conditionContext.getEnvironment();
        System.out.println(env.getActiveProfiles());
        return env.containsProperty("magic");
    }
}

使用

    @Bean
    @Conditional(MagicExistsCondition.class)
    public CompactDisc sgtPeppers(){
        return new SgtPeppers();
    }

这样，只有在上下文环境中有属性magic才会装配bean
keywords:@Conditional,Conditional

自动装配歧义性的处理方式

当自动装配@autowired的时候，如果有多个类都实现了这个接口，那么会抛出异常

首选bean
```
  @Bean
  @Primary
  public CompactDisc sgtPeppers(){
      return new SgtPeppers();
  }
```
问题:只能有一个被@Primary注解，若有多个实现同一接口的类注解则抛出异常

限定自装配bean

指定想要注入进去的是哪个bean
  @Autowired
  @Qualifier("cdPlayer")
  private MediaPlayer player;
创建自定义限定符
@Component
@Qualifier("cdPlayer")
public class CDPlayer implements MediaPlayer{}
以上是通过javaconfig配置的bean，则@Bean要与@Qualifier配合使用
  @Bean
  @Qualifier("cdPlayer")
  public CDPlayer cdPlayer(CompactDisc cd){
      return new CDPlayer(cd);
  }

问题:如果一个类需要有多个限定符修饰，那么使用多个@Qualifier修饰是非法的，但是可以通过自定义限定符实现

自定义限定符，需要被@Qualifier注解
@Qualifier
public @interface Creamy{}
@Qualifier
public @interface Cold{}
使用:
@Creamy
@Cold
public class IceCream implements Dessert{}

keywords:@Qualifier

bean作用域

定义了多个作用域:Singleton(单例) Prototype(原型) Session(会话) Request(请求)

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class CDPlayer implements MediaPlayer{}

注意:如果一个bean注入的另一个bean生命周期比他小的话(例如单例与会话),则需要创建一个作用域代理?

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode=ScopedProxyMode.INTERFACES)
public class CDPlayer implements MediaPlayer{}

xml中声明

<bean id="cart" class="xxx" scope="session">
	<aop:scoped-proxy/>
</bean>
注意需要在xml中声明命名空间

keywords:@Scope,scope

运行时注入

属性占位符

javaconfig配置bean的方式
@PropertySource("classpath:springdemo/app.properties")
public class CDPlayerConfig {
  @Bean
  @Qualifier("cdPlayer")
  public CDPlayer cdPlayer(CompactDisc cd){
      return new CDPlayer(cd, env.getProperty("disc.name"));
  }	
}
这里将app.properties里的disc.name加入到构造函数中

解析属性占位符,占位符语法(${})

如果不通过javaconfig配置bean
<bean id="mediaPlayer" class="springdemo.CD.CDPlayer" c:cd-ref="compactDisc" c:name="${disc.name}">
或者在定义类的时候，通过@Value
@Component
public class CDPlayer implements MediaPlayer{
    private CompactDisc cd;
    private String name;
    @Autowired
    public CDPlayer(CompactDisc cd, @Value("${disc.name}") String name){
        this.cd = cd;
        this.name = name;
    }
}

为了使用占位符，必须配置PropertySourcesPlaceholderConfigurer

javaconfig配置:
    @Bean
    public static PropertySourcesPlaceholderConfigurer placeholderConfigurer(){
        return new PropertySourcesPlaceholderConfigurer();
    }
xml配置:
<context:property-placeholder/>

keywords:@PropertySource,env.getProperty,${},PropertySourcesPlaceholderConfigurer,

Spring表达式语言(SpEL)

Spring概述

2017-10-28T00:00:00+00:00

关于Spring的简述

简化java开发

关键策略点 1.基于POJO的轻量级和最小侵入性编程 2.通过依赖注入和面向接口实现松耦合

紧耦合
private RescueDamseQuest quest;
public DamselRecuingKight(){
	this.quest = new RescueDamseQuest();
}
松耦合
private Quest quest;
public DamselRecuingKight(Quest quest){
	this.quest = quest;
}
这种就是构造注入

在spring中，通过xml配置或者java配置实现依赖注入 3.基于切面和惯例进行声明式编程

public BraveKnight(Quest quest, Minstrel minstrel){
	...
}
public void embarkOnQuest(){
	minstrel.singBeforeQuest();
	quest.embark();
	minstrel.singAfterQuest();
}
可见,管理Minstrel其实并不是Knight的职责，并且如果以后需要一个不需要Minstrel的Knight,代码复杂度过高
将Minstrel声明为一个切片可以免去这些繁琐的代码

4.通过切面和模板减少样板式代码

容纳bean

容器时spring框架的核心，使用DI管理构成应用的组件，创建相互协作的组件关联 spring容器归为： bean工厂：最简单的容器，提供DI支持应用上下文：基于BeanFactory构建，提供框架级别的服务

应用上下文 AnnotationConfigApplicationContext：从一个或多个基于Java的配置类中加载Spring应用上下文。 AnnotationConfigWebApplicationContext：从一个或多个基于Java的配置类中加载Spring Web应用上下文。 ClassPathXmlApplicationContext：从类路径下的一个或多个XML配置文件中加载上下文定义，把应用上下文的定义文件作为类资源。 FileSystemXmlapplicationcontext：从文件系统下的一个或多个XML配置文件中加载上下文定义。 XmlWebApplicationContext：从Web应用下的一个或多个XML配置文件中加载上下文定义
bean生命周期

Spring模块

Spring核心容器容器是Spring框架最核心的部分，它管理着Spring应用中bean的创建、配置和管理。在该模块中，包括了Spring bean工厂，它为Spring提供了DI的功能。基于bean工厂，我们还会发现有多种Spring应用上下文的实现，每一种都提供了配置Spring的不同方式 Spring的AOP模块在AOP模块中，Spring对面向切面编程提供了丰富的支持。这个模块是Spring应用系统中开发切面的基础。数据访问与集成 Web与远程调用

Jvm线程安全与锁优化

2017-10-26T00:00:00+00:00

Jvm线程安全与锁优化

关于线程安全

线程安全：当多个线程访问一个对象，不用考虑这些线程在运行时环境下的调度和交替工作，都可以获得正确的结果，那么就是线程安全
即代码本身封装了所有必要的保障手段，调用者无须关心多线程带来的问题

共享数据分类
1.不可变
如果共享的数据是一个基本类型，只要final修饰即可；如果是一个对象，则需要保证对象行为不会对其状态产生任何影响，例如将对象中带有状态的变量声明为final
```
class Integer{
  private final int value;
  public Integer(int value){this.value = value;}
}
```
2.绝对线程安全
java api自己的一些线程安全类大多数都不是绝对的线程安全
```
Vector<Integer> ve = new Vector<>();
此时向ve注入一些数据，两个线程一个删除，一个读取，那么在一定情况下，可能会由于一个线程删除了一个元素，导致另一个线程通过序号访问时，序号不可用，抛出越界异常
此时还是需要在调用端通过synchronized(ve){dosomething()..}
```
3.相对线程安全
大多数线程安全类都属于相对线程安全，就是说只能保证这个对象单独操作是线程安全的，但是对于一些特定顺序连续调用，可能需要在调用端试用结果额外同步手段保证调用正确性
4.线程兼容
对象本身不是线程安全，但是通过调用端使用同步手段保证对象在并发环境中可安全调用
5.线程对立
无论调用端是否采取了同步措施，都无法再多线程环境中并发使用的代码

线程安全的实现方法

互斥同步
指的就是多线程访问共享数据时，保证共享数据在同一时刻只被一个线程使用
synchronized：
会在同步块的前后行程monitorenter和monitorexit字节码指令，并且需要一个reference类型参数指名锁定和解锁的对象；如果指名了对象参数，就是这个对象的refernce，否则根据synchronized修饰的是实力方法or类方法，去取对应对象实例or Class对象作为锁对象
当执行到monitorenter时，首先尝试对象是否锁定，如果没有锁定或当前线程已有那个对象的锁，就将锁的计数器+1；在执行monitorexit时，会将锁的计数器-1，至计数器=0，锁被释放成功；如果获取对象锁失败，则线程进入阻塞等待
由于java线程是映射到操作系统原生线程的，所以在阻塞或唤醒线程都是需要从用户态转换到核心态，存在耗时
ReentrantLock：
java.util.concurrent(JUC)中的重入锁
向对synchronized提供了一些更高级的功能:
1.等待可中断：等待的线程可以选择放弃等待，处理其他事情
2.公平锁：多个线程等待同一个锁时，必须按照申请锁的时间顺序获取锁 3.锁绑定多个条件：一个ReentrantLock对象可绑定多个condition对象，synchronized如果要完成相同功能则需要额外添加一个锁
非阻塞同步
先操作，如果没有其他线程用共享数据，操作成功；若有争用，发生冲突时再采取其他补偿措施(不断重试，直到成功)，不需要将线程挂起
无同步方案
如果一个方法不涉及共享数据，那么无须同步措施去保证正确性，有些代码天生就是线程安全
可重入代码
不依赖存储在堆上的数据和公用系统资源，用到的状态量由参数传入，不调用非可重入的方法线程本地存储
如果能保证共享数据的代码在同一线程执行，就无需同步也能保证线程之间不出现数据争用
例如生产者 - 消费者模式、ThreadLocal

锁优化

自旋锁与自适应自旋
因为互斥同步对性能最大影响是阻塞的实现，所以如果物理机有一个以上处理器，就能让两个或以上线程并行执行，则可以让后面请I去锁的线程稍等(不放弃处理器执行时间)，进入自旋(忙循环) 自旋锁占用处理器时间，若锁占用时间短，则自旋等待效果很好，当超过限定次数还没获取锁，则会使用传统方式挂起线程
锁消除
如果代码中存在一些上了锁但是锁上的对象是不可能存在共享数据竞争的，则会将这些锁消除掉。一句是逃逸分析的数据支持，若不会堆逃逸，则将他们当作栈上数据对待，则线程私有
锁粗化
当虚拟机探测到连续的操作对同一个对象反复加锁解锁，则会将范围扩展到整个操作序列外部
轻量级锁
偏向锁

Jvm内存模型与线程

2017-10-25T00:00:00+00:00

关于Jvm内存模型与线程主要介绍虚拟机如何实现多线程、多线程之间共享竞争数据导致的问题及解决方案

关于内存模型

基于高速缓存解决了处理器与内存之间的速度矛盾，但是每个处理器都有自己的告诉缓存，然而共享同一主内存，为了避免各个缓存数据的不一致，牵扯到一个缓存的一致性问题，所以各个处理器访问缓存时都要遵循一些操作协议
内存模型：特定操作协议下，对特定内存或高速缓存进行读写访问

Java内存模型

Java内存模型：用于屏蔽各种硬件和操作系统的内存访问差异

主内存&工作内存
Java内存模型主要是定义程序中各个变量的访问规则(包括实例变量、静态变量和构成数组对象的元素，但不包括局部变量和方法参数，因为这些是线程私有)
Java内存模型规定所有变量存储在主内存中(类似前面共享的主内存)；每条线程还有自己的工作内存(类似处理器的高速缓存)；线程的工作内存中保留了被该线程使用变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行；不同线程无法直接访问对方工作内存中的变量；线程间变量值传递需要通过主内存完成
内存间交互操作
那么变量是如何从主内存拷贝到工作内存，又是如何从工作内存同步主内存的呢？主要通过8种操作 java内存模型还规定了几个必须满足的规则:
1.一个变量同一时刻只允许一条线程对其进行lock，但一个线程可以对其Lock多次，然而也有执行相应次数的unlock，变量才能被正确解锁
2.如果堆变量执行Lock，会清空工作内存中此变量的值，执行引擎使用这个变量前，要重新执行Load,assign操作初始化
3.如果一个变量没有被lock，那么也不可以被unlock，也不允许unlock一个被其他线程lock的变量 4.在unlock前，需要将变量同步回主内存中
关于volatile变量的特殊规则
volatile具备两种特性：
1.保证此变量对所有线程可见(一个线程改了值，另一个线程是立即可知的)
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存
由于java的运算非原子操作，volatile变量的运算在并发下是不安全的
eg:
```
for(;;){
  something 
  // 如果线程内该值没有被volatile修饰，那么在进入线程时，只会从主内存同步一次这个值
  // 如果线程内该值被volatile修饰，那么每次访问这个变量都会从主内存中重新读取该值
}
```
2.禁止指令重排序优化
```
线程a
static boolean flag = false;
dosomething()...
flag = true;
线程b
while(!flag){
  // sleep()
}
dosomething()...
```
上面如果flag不用volatile修饰，则flag = true可能被提前执行(指令重排序优化)
volatile的作用
volatile同步性能优于锁
注：线程T，V/W表示两个volatile变量
1.线程对V的操作必须要满足顺序如下：load -> use ; use -> load；也就是要求在工作内存中，每次使用V前都要先从主内存刷新最新值
2.线程对V的操作必须满足：assign -> store ; store -> aassign；也就是要求在工作内存中，每次修改V后都必须同步到主内存中
long&double特殊规则
虽然java内存模型要求上述8个操作都具有原子性，但是对于64位数据类型，则规定：
允许虚拟机将选择不保证没有被volatile修饰的64位数据类型的load,store,read,write的原子性，也就是如果多个线程同时共享一个未声明volatile的long或double，则有可能取到一个既非原值，又不是其他线程修改后的数值
原子性可见性有序性
原子性：由java内存模型保证的原子性包括：load,store,read,write,assign,use;提供了monitorenter和monitorexit隐式的使用者两个操作，反应到java代码便是同步块synchronized
可见性：当一个线程修改了共享变量的值，其他线程能立刻得知，普通变量和volatile区别是，volatile保证了新值能立即同步到主内存，以及每次使用前都立即从主内存刷新；
除了volatile，java还有synchronized和final能保证可见性
synchronized是由对一个变量执行unlock前，会将变量同步回主内存
final是指被final修饰的字段在构造器中一旦初始化完成，其他线程就能看到final字段的值有序性：如果在本线程内观察，所有操作都是有序的，如果在一个线程中观察另一个线程，所有操作都是无序的
java提供了volatile和synchronized关键字保证操作的有序性，synchronzied确保一个变量在同一时刻只能允许一条线程对其进行lock操作，决定持有同一个锁的两个同步块只能串行进入
先行发生原则
是判断数据是否存在竞争、线程是否安全的主要依据
什么是先行发生？
指java内存模型中定义的两个操作之间的偏序关系，如果说操作A先行发生于操作B，就是说操作B前，操作A产生的影响能被操作B观察到
如果两个操作关系不在以下列，则没有顺序性保障，虚拟机可以对他们随意重排序

Java的线程

线程的实现
1.使用内核线程
直接由操作系统内核支持的线程，一般轻量级进程就是我们通常所讲的线程
2.使用用户线程
用户线程的简历、同步、销毁和调度在用户态中完成，不需要内核的帮助，java等语言已经放弃使用用户线程了
3.使用用户线程加轻量级进程

Java线程的实现还是使用一对一的模型实现，即一条java线程映射到一条轻量级进程中

java线程调度(CPU的使用权)
1.协同式
执行时间由线程本身控制，自己处理完后通知系统切换到另一个线程
优势：简单，且没有现成同步问题
劣势：执行时间不可控，可能会导致程序阻塞
2.抢占式
执行时间由系统分配(在java中可以通过yield让出执行时间,但是无法获取执行时间)
优势：执行时间系统可控，不会有一个线程导致进行阻塞
java可以通过设置优先级，给线程分配时间
状态转换
java定义了5种线程状态，任意一个时间点，一个线程只能有且只有一种状态注：wait和block的区别是，阻塞是等待着获取一个排它锁；而等待是等待一段时间或唤醒动作的发生.