<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[limin0983的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/limin0983</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; limin0983]]></copyright><item><title><![CDATA[Volatile关键字]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/76944522</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/76944522</guid><author>limin0983</author><pubDate>Tue, 08 Aug 2017 21:52:54 +0800</pubDate><description><![CDATA[package volatileTest;    
public class RunThread extends Thread {    
 private boolean isRunning = true;    
 public boolean isRunning(){    
  return isRunning;    
 }    
 public void setRunning(bool]]></description><category></category></item><item><title><![CDATA[面试之JDBC总结]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/73500035</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/73500035</guid><author>limin0983</author><pubDate>Tue, 20 Jun 2017 16:27:28 +0800</pubDate><description><![CDATA[一、相关概念
1、 什么是JDBC
       JDBC （Java Data Base Connectivity,java 数据库连接）是一种用于执行sql语句的java API，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。
2、 JDBC架构
        JDBC API支持两层和三层处理模型进行数据库访问，但一般的JDBC体系结构由两层组成：
]]></description><category></category></item><item><title><![CDATA[String字符串]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/73469547</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/73469547</guid><author>limin0983</author><pubDate>Mon, 19 Jun 2017 17:25:40 +0800</pubDate><description><![CDATA[public static void main(String[] args) {
		String str1 = "hello";
		String str2 = "he"+"llo";
		String str3 = "he"+new String("llo");
		System.out.println(str1 == str2);//true
		System.out.println(str]]></description><category></category></item><item><title><![CDATA[JAVA的位运算与二进制转换]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/72956189</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/72956189</guid><author>limin0983</author><pubDate>Fri, 09 Jun 2017 11:54:22 +0800</pubDate><description><![CDATA[Java的位运算符与二进制转换

转换：
Java整型数据类型有：byte、char、short、int、long。要把它们转换成二进制的原码形式，必须明白他们各占几个字节。，一个字节==8位数
 数据类型                           所占位数
      byte                                       8 
      b]]></description><category></category></item><item><title><![CDATA[Java并发容器和框架]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/71172668</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/71172668</guid><author>limin0983</author><pubDate>Thu, 04 May 2017 17:25:14 +0800</pubDate><description><![CDATA[1.       ConcurrentHashMap
 
ConcurrentHashMap是线程安全并且高效的HashMap。
 
1.1   为什么使用ConcurrentHashMap？
（1）      HashMap 是线程不安全的，在多线程环境下使用HashMap的put操作会使Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next指针将永远不为null，]]></description><category></category></item><item><title><![CDATA[线程安全与锁优化]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/71104789</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/71104789</guid><author>limin0983</author><pubDate>Tue, 02 May 2017 22:31:06 +0800</pubDate><description><![CDATA[1.1   java中的线程安全
线程安全是限定在多个线程之间存在共享数据访问前提下的，按照线程安全的安全程度，各种操作的共享数据可以分为：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
线程安全的实现方法：同步和锁机制
（1）互斥同步：是常见的一种并发正确性保障手段。同步是指子啊多个线程访问共享数据时，保证数据在同一时刻只能被一个（或一些线程，在使用信号量的时候）线程使用。
而]]></description><category></category></item><item><title><![CDATA[java 内存模型与线程]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/71082448</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/71082448</guid><author>limin0983</author><pubDate>Tue, 02 May 2017 16:14:52 +0800</pubDate><description><![CDATA[Java内存模型与线程

 

 
1.1  硬件效率与一致性
 多任务处理是在现在计算机操作系统中几乎已经是一项必备的功能了。让计算机同时处理几项任务不仅因为计算机的运算能力强大，还因为计算机的运算速度与它的存储和通信子系统速度的差距太大，大量的时间都花费在磁盘I/O、或网络通信或数据库访问上，这样就导致处理器大部分时间都处在等待其他资源的状态。
    由于计算机的存储设备与处理]]></description><category></category></item><item><title><![CDATA[虚拟机类加载机制小结]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/71082280</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/71082280</guid><author>limin0983</author><pubDate>Tue, 02 May 2017 16:00:53 +0800</pubDate><description><![CDATA[1.1虚拟机的类加载机制
虚拟机的类加载机制：虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化,最终形成可以被虚拟机直接使用的java类型。在java语言里面，类型的加载、连接和初始化都是在程序运行期间完成的，java里天生动态扩展的语言特性就是依赖于运行期间动态加载和动态链接这个特点实现的。
        类加载顺序：类从被加载到虚拟机内存开始，到卸载处内]]></description><category></category></item><item><title><![CDATA[垃圾收集器]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70846731</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70846731</guid><author>limin0983</author><pubDate>Thu, 27 Apr 2017 11:17:59 +0800</pubDate><description><![CDATA[对于程序计数器、虚拟机栈、本地方法栈随着线程而生，随着线程而灭，在这几个区域内就不需要过多的考虑垃圾回收的问题，因为方法结束或线程结束后，内存自然就跟着收回了。而java堆和方法区则不一样，压机回收器所关注的也是这部分内存。
1. 如何判断对象已死？
1.1 引用计数算法
    引用计数算法：给对象添加一个引用计数器，每当有一个地方引用它，计数器值就加1；当引用失效时，计数器值就减1；任何]]></description><category></category></item><item><title><![CDATA[java内存区域]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70841452</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70841452</guid><author>limin0983</author><pubDate>Thu, 27 Apr 2017 09:45:55 +0800</pubDate><description><![CDATA[Java 虚拟机在执行java程序的过程中会把它所管理的内存区域划分为若干个不同的数据区域。这些区域都有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有的区域则依赖用户线程的启动和结束而建立和销毁。
Java虚拟机所管理的内存包括以下几个运行数据区域：程序计数器，虚拟机栈，本地方法栈，堆，方法区
（1）程序计数器：程序计数器是一块较小的内存区域，可以看作是当前线程所执行]]></description><category></category></item><item><title><![CDATA[单例模式与多线程2]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70810754</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70810754</guid><author>limin0983</author><pubDate>Wed, 26 Apr 2017 17:54:36 +0800</pubDate><description><![CDATA[接 单例模式与多线程
1.6 使用static 代码块实现单例模式
  由于静态代码块在类加载时就已经执行了，所以可以应用静态代码块的该特性来设计单例模式。
package testSingleton2;

public class MyObject {
	private static MyObject myObject = null;
	private MyObject(){}
	stat]]></description><category></category></item><item><title><![CDATA[单例模式与多线程]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70792535</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70792535</guid><author>limin0983</author><pubDate>Wed, 26 Apr 2017 11:47:40 +0800</pubDate><description><![CDATA[如何使单例模式遇到多线程使安全的，正确的。
1.1单例模式之饿汉模式
      饿汉模式（立即加载）：就是使用类的时候已经将对象创建完毕，常见的实现办法就是直接new 实例化。
      立即加载是在方法调用前，实例已经被创建了，实现代码如下：
package testSingleton;

public class MyObject {
     private static MyO]]></description><category></category></item><item><title><![CDATA[InheritableThreadLocal类和ThreadLocal类]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70760783</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70760783</guid><author>limin0983</author><pubDate>Tue, 25 Apr 2017 18:05:45 +0800</pubDate><description><![CDATA[类ThreadLocal主要解决的就是：变量在不同线程间的隔离性，也就是每个线程拥有自己的值。
InheritableThreadLocal类是ThreadLocal类的子类，使用InheritableThreadLocal 可以在子线程中取得父线程继承下来的值。
注意：

如果ThreadLocal存储的是不变性（immutable）的对象，如String，对于主线程设置的值子线程可以通]]></description><category></category></item><item><title><![CDATA[synchronized同步方法2]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70598702</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70598702</guid><author>limin0983</author><pubDate>Mon, 24 Apr 2017 15:50:37 +0800</pubDate><description><![CDATA[接上一篇synchronized同步方法
关键字synchronized取得的锁都是对象锁，而不是把一段代码或方法当作锁。对于多个线程同时执行一个对象的一个同步方法，哪个线程先执行带synchronized关键字的方法，哪个线程就持有了该方法所属对象的锁Lock，那么其他线程只能呈等待状态。

2. 如何通过synchronized关键字解决脏读
代码：

package testSy]]></description><category></category></item><item><title><![CDATA[synchronized同步方法]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70578486</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70578486</guid><author>limin0983</author><pubDate>Mon, 24 Apr 2017 11:47:51 +0800</pubDate><description><![CDATA[多个对象多个锁
package testSynchronized;

public class Task {
	private int num = 0;
	synchronized public void addI(String username){
		try{
			if(username.equals("a")){
				num = 100;
				System.out.println]]></description><category></category></item><item><title><![CDATA[数据结构与算法之栈与队列]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70304767</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70304767</guid><author>limin0983</author><pubDate>Thu, 20 Apr 2017 20:59:18 +0800</pubDate><description><![CDATA[package StackAndQueueSummary;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 4.用两个队列实现栈
 * 基本思路：使用queue1和queue2两个队列轮流存储数据。
 * 这个轮流发生再pop和peek操作的时候，
 * 假设此时我们把所有的数据存储在queue1中（queue2为空），我]]></description><category></category></item><item><title><![CDATA[数据结构与算法之栈与队列]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70304734</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70304734</guid><author>limin0983</author><pubDate>Thu, 20 Apr 2017 20:57:41 +0800</pubDate><description><![CDATA[package StackAndQueueSummary;

import java.util.Stack;

/**
 * 3.用两个栈实现队列
 * 实现对列，就是要实现它的3个方法：enqueue(入队),dequeue(出对),peek(队头)
 * 基本思路：
 * （1）stack1 存的是每次进来的元素，所以enqueue就是把进来的元素存入push到stack1中。
 * （2）而]]></description><category></category></item><item><title><![CDATA[数据结构与算法之栈与队列]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70304711</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70304711</guid><author>limin0983</author><pubDate>Thu, 20 Apr 2017 20:56:45 +0800</pubDate><description><![CDATA[package StackAndQueueSummary;

import java.util.Stack;

/*
 * 设计一个栈，实现min，push。pop
 * 上一个方法是使用一个辅助栈来存储最小元素，
 * 现在这个方法使用一个栈，一个栈当两个栈使用，
 * 就是说：每次push操作的时候，先入栈当前要被栈的元素，在入栈当前栈中最小的元素；
 * 同理，pop操作也是每次弹出两个元素]]></description><category></category></item><item><title><![CDATA[数据结构与算法之栈与队列]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70304691</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70304691</guid><author>limin0983</author><pubDate>Thu, 20 Apr 2017 20:54:42 +0800</pubDate><description><![CDATA[package StackAndQueueSummary;
import java.util.Stack;
//设计含min函数的栈，要求min、push、pop的时间复杂度都是O(1)
/* 存入元素以整数为例
 * 算法思想：需要设计一个辅助栈，用来存储当前栈中元素的最小值。
 * 网上有人说存储最小元素的位置，虽然节省空间，但是在每次调用min函数的时候，只能得到对
 * 只能得到位置信息，]]></description><category></category></item><item><title><![CDATA[数据结构与算法之栈：反转一个栈的两种解法]]></title><link>https://blog.youkuaiyun.com/limin0983/article/details/70280484</link><guid>https://blog.youkuaiyun.com/limin0983/article/details/70280484</guid><author>limin0983</author><pubDate>Thu, 20 Apr 2017 17:56:05 +0800</pubDate><description><![CDATA[问题描述：要求反转一个栈，
例如:栈A 中元素从栈底到栈顶依次为：1，2，3，4，5；要求对A反转后，A中元素从栈底到栈顶为 5，4，3，2，1


解法一：比较简单的想法是使用一个辅助栈，类似于汉诺塔问题。
            假设：要被反转的栈为A，大小为N，辅助栈为B；
                      基本思路：
                        ]]></description><category></category></item></channel></rss>