轩辕花狐貂
轩辕花狐貂

多线程编程（三）--Thread常用方法以及ThreadLocal

一、Thread常用方法

在多线程编程中，thread类是很常用的。接下来就来学习一些常用的方法。

1）获取线程对象的名称和设置线程对象的名称

public final String getName():获取线程的名称。

public final void setName(String name):设置线程的名称

 * 针对不是Thread类的子类中如何获取线程对象名称呢?
 * public static Thread currentThread():返回当前正在执行的线程对象
 * Thread.currentThread().getName()

package cn.itcast_03;

/*
 * 该类要重写run()方法,为什么呢?
 * 不是类中的所有代码都需要被线程执行的。
 * 而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。
 */
public class MyThread extends Thread {
	public MyThread() {
	}
	
	public MyThread(String name){
		super(name);
	}

	@Override
	public void run() {
		// 自己写代码
		// System.out.println("好好学习，天天向上");
		// 一般来说，被线程执行的代码肯定是比较耗时的。所以我们用循环改进
		for (int x = 0; x < 10; x++) {
			System.out.println(Thread.currentThread().getName()+"=="+getName() + ":" + x);
		}
	}
	
	
	

}

测试：

package cn.itcast_03;

/*
 * 如何获取线程对象的名称呢?
 * public final String getName():获取线程的名称。
 * 如何设置线程对象的名称呢?
 * public final void setName(String name):设置线程的名称
 * 
 * 针对不是Thread类的子类中如何获取线程对象名称呢?
 * public static Thread currentThread():返回当前正在执行的线程对象
 * Thread.currentThread().getName()
 */
public class MyThreadDemo {
	public static void main(String[] args) {
		// 创建线程对象
		//无参构造+setXxx()
		 MyThread my1 = new MyThread();
		 MyThread my2 = new MyThread();
		 //调用方法设置名称
		 my1.setName("林青霞");
		 my2.setName("刘意");
		 my1.start();
		 my2.start();
		
		//带参构造方法给线程起名字
//		 MyThread my1 = new MyThread("林青霞");
//		 MyThread my2 = new MyThread("刘意");
//		 my1.start();
//		 my2.start();
//		
		//我要获取main方法所在的线程对象的名称，该怎么办呢?
		//遇到这种情况,Thread类提供了一个很好玩的方法:
		//public static Thread currentThread():返回当前正在执行的线程对象
		System.out.println(Thread.currentThread().getName());
	}
}

/*
名称为什么是：Thread-? 编号

class Thread {
	private char name[];

	public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }
    
     private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
        //大部分代码被省略了
        this.name = name.toCharArray();
    }
    
    public final void setName(String name) {
        this.name = name.toCharArray();
    }
    
    
    private static int threadInitNumber; //0,1,2
    private static synchronized int nextThreadNum() {
        return threadInitNumber++; //return 0,1
    }
    
    public final String getName() {
        return String.valueOf(name);
    }
}

class MyThread extends Thread {
	public MyThread() {
		super();
	}
}

*/
main
轩辕==轩辕:0
轩辕==轩辕:1
花狐貂==花狐貂:0
花狐貂==花狐貂:1
花狐貂==花狐貂:2
花狐貂==花狐貂:3
花狐貂==花狐貂:4
花狐貂==花狐貂:5
花狐貂==花狐貂:6
花狐貂==花狐貂:7
花狐貂==花狐貂:8
花狐貂==花狐貂:9
轩辕==轩辕:2
轩辕==轩辕:3
轩辕==轩辕:4
轩辕==轩辕:5
轩辕==轩辕:6
轩辕==轩辕:7
轩辕==轩辕:8
轩辕==轩辕:9

注意：在使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序是无关的。

2）获取线程对象的优先级和设置线程对象的优先级

注意：在我们的计算机只有一个cpu，那么cpu在某一时刻只能执行一条指令，线程只有得到cpu时间片，也就是使用权，才可以执行指令，那么Java是如何对线程进行调度的呢。

线程调度有两种模型分时调度和抢占式调度。

分时调度模型：所有线程轮流执行cpu的使用权，平均分配每个线程占用cpu的时间片。

抢占式调度模型：优先让优先级高的线程使用cpu的执行权，如果线程优先级相同，那么随机选择一个。优先级高的线程获取CPU时间片相对多一些。


public final int getPriority():返回线程对象的优先级

public final void setPriority(int newPriority)：更改线程的优先级。 

package cn.itcast_04;

public class ThreadPriority extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

package cn.itcast_04;

/*
 * 我们的线程没有设置优先级,肯定有默认优先级。
 * 那么，默认优先级是多少呢?
 * 如何获取线程对象的优先级?
 * 		public final int getPriority():返回线程对象的优先级
 * 如何设置线程对象的优先级呢?
 * 		public final void setPriority(int newPriority)：更改线程的优先级。 
 * 
 * 注意：
 * 		线程默认优先级是5。
 * 		线程优先级的范围是：1-10。
 * 		线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。
 * 		
 * IllegalArgumentException:非法参数异常。
 * 抛出的异常表明向方法传递了一个不合法或不正确的参数。 
 * 
 */
public class ThreadPriorityDemo {
	public static void main(String[] args) {
		ThreadPriority tp1 = new ThreadPriority();
		ThreadPriority tp2 = new ThreadPriority();
		ThreadPriority tp3 = new ThreadPriority();

		tp1.setName("东方不败");
		tp2.setName("岳不群");
		tp3.setName("林平之");

		// 获取默认优先级--
		// System.out.println(tp1.getPriority());
		// System.out.println(tp2.getPriority());
		// System.out.println(tp3.getPriority());

		// 设置线程优先级--线程优先级的范围是：1-10。IllegalArgumentException:非法参数异常。抛出的异常表明向方法传递了一个不合法或不正确的参数
		// tp1.setPriority(100000);
		
		//设置正确的线程优先级
		tp1.setPriority(10);
		tp2.setPriority(1);

		tp1.start();
		tp2.start();
		tp3.start();
	}
}

运行结果： 
东方不败:0
东方不败:1
东方不败:2
东方不败:3
东方不败:4
东方不败:5
东方不败:6
东方不败:7
东方不败:8
岳不群:0
东方不败:9
林平之:0
林平之:1
林平之:2
林平之:3
林平之:4
林平之:5
岳不群:1
林平之:6
岳不群:2
岳不群:3
林平之:7
岳不群:4
岳不群:5
岳不群:6
岳不群:7
岳不群:8
岳不群:9
林平之:8
林平之:9

3）线程控制之线程休眠

public static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠

public static void sleep(long millis, int nanos):在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）

package cn.itcast_04;

import java.util.Date;

public class ThreadSleep extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x + ",日期：" + new Date());
			// 睡眠
			// 困了，我稍微休息1秒钟
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}


package cn.itcast_04;

/*
 * 线程休眠
 *		public static void sleep(long millis)
 */
public class ThreadSleepDemo {
	public static void main(String[] args) {
		ThreadSleep ts1 = new ThreadSleep();
		ThreadSleep ts2 = new ThreadSleep();
		ThreadSleep ts3 = new ThreadSleep();

		ts1.setName("林青霞");
		ts2.setName("林志玲");
		ts3.setName("林志颖");

		ts1.start();
		ts2.start();
		ts3.start();
	}
}
运行结果： 
林志玲:0,日期：Mon Apr 16 12:44:01 CST 2018
林青霞:0,日期：Mon Apr 16 12:44:01 CST 2018
林志颖:0,日期：Mon Apr 16 12:44:01 CST 2018
林志玲:1,日期：Mon Apr 16 12:44:02 CST 2018
林志颖:1,日期：Mon Apr 16 12:44:02 CST 2018
林青霞:1,日期：Mon Apr 16 12:44:02 CST 2018
林志玲:2,日期：Mon Apr 16 12:44:03 CST 2018
林志颖:2,日期：Mon Apr 16 12:44:03 CST 2018
林青霞:2,日期：Mon Apr 16 12:44:03 CST 2018
林志玲:3,日期：Mon Apr 16 12:44:04 CST 2018
林青霞:3,日期：Mon Apr 16 12:44:04 CST 2018
林志颖:3,日期：Mon Apr 16 12:44:04 CST 2018
林志颖:4,日期：Mon Apr 16 12:44:05 CST 2018
林志玲:4,日期：Mon Apr 16 12:44:05 CST 2018
林青霞:4,日期：Mon Apr 16 12:44:05 CST 2018
林志颖:5,日期：Mon Apr 16 12:44:06 CST 2018
林青霞:5,日期：Mon Apr 16 12:44:06 CST 2018
林志玲:5,日期：Mon Apr 16 12:44:06 CST 2018
林志颖:6,日期：Mon Apr 16 12:44:07 CST 2018
林志玲:6,日期：Mon Apr 16 12:44:07 CST 2018
林青霞:6,日期：Mon Apr 16 12:44:07 CST 2018
林志颖:7,日期：Mon Apr 16 12:44:08 CST 2018
林青霞:7,日期：Mon Apr 16 12:44:08 CST 2018
林志玲:7,日期：Mon Apr 16 12:44:08 CST 2018
林志颖:8,日期：Mon Apr 16 12:44:09 CST 2018
林志玲:8,日期：Mon Apr 16 12:44:09 CST 2018
林青霞:8,日期：Mon Apr 16 12:44:09 CST 2018
林志颖:9,日期：Mon Apr 16 12:44:10 CST 2018
林志玲:9,日期：Mon Apr 16 12:44:10 CST 2018
林青霞:9,日期：Mon Apr 16 12:44:10 CST 2018

4）线程控制之线程加入

public final void join():等待该线程终止。

public final synchronized void join(long millis)：等待该线程终止的时间最长为 millis 毫秒

public final synchronized void join(long millis, int nanos)：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

package cn.itcast_04;

public class ThreadJoin extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

package cn.itcast_04;

/*
 * public final void join():等待该线程终止。 
 */
public class ThreadJoinDemo {
	public static void main(String[] args) {
		ThreadJoin tj1 = new ThreadJoin();
		ThreadJoin tj2 = new ThreadJoin();
		ThreadJoin tj3 = new ThreadJoin();

		tj1.setName("李渊");
		tj2.setName("李世民");
		tj3.setName("李元霸");

		tj1.start();
		try {
			tj1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		tj2.start();
		tj3.start();
	}
}


李渊:0
李渊:1
李渊:2
李渊:3
李渊:4
李渊:5
李渊:6
李渊:7
李渊:8
李渊:9
李世民:0
李世民:1
李世民:2
李元霸:0
李元霸:1
李元霸:2
李元霸:3
李元霸:4
李元霸:5
李元霸:6
李元霸:7
李元霸:8
李元霸:9
李世民:3
李世民:4
李世民:5
李世民:6
李世民:7
李世民:8
李世民:9

为什么要用join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

不加join()

package cn.itcast_04;

public class ThreadJoin_01 extends Thread {
    private  String name;
    
    public ThreadJoin_01(String name){
    	super(name);
    	this.name=name;
    }
    
    @Override
	public void run() {
    	System.out.println(Thread.currentThread().getName() + " 线程运行开始!");
    	for(int i=0;i<5;i++){
    		System.out.println("循环中子线程"+name + "运行 : " + i);
    		try {
				sleep((int) Math.random() * 10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}  
    	}
    	System.out.println(Thread.currentThread().getName() + " 线程运行结束!");  
    	
    }
}

package cn.itcast_04;

public class ThreadJoinDemo_01 {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName()+"主线程运行开始!");
		ThreadJoin_01 tj1=new ThreadJoin_01("李渊");
		ThreadJoin_01 tj2=new ThreadJoin_01("李元霸");
		tj1.start();
		tj2.start();
		System.out.println(Thread.currentThread().getName()+ "主线程运行结束!"); 

	}

}

运行结果： 
main主线程运行开始!
李渊 线程运行开始!
循环中子线程李渊运行 : 0
main主线程运行结束!
李元霸 线程运行开始!
循环中子线程李元霸运行 : 0
循环中子线程李渊运行 : 1
循环中子线程李渊运行 : 2
循环中子线程李元霸运行 : 1
循环中子线程李元霸运行 : 2
循环中子线程李元霸运行 : 3
循环中子线程李元霸运行 : 4
李元霸 线程运行结束!
循环中子线程李渊运行 : 3
循环中子线程李渊运行 : 4
李渊 线程运行结束!

发现主线程比子线程早结束。

加入join()方法

package cn.itcast_04;

public class ThreadJoinDemo_02 {

	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName()+"主线程运行开始!");
		ThreadJoin_01 tj1=new ThreadJoin_01("李渊");
		ThreadJoin_01 tj2=new ThreadJoin_01("李元霸");
		tj1.start();
		tj2.start();
		try {
			tj1.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			tj2.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+ "主线程运行结束!"); 

	}

}

运行结果：

main主线程运行开始!
李元霸 线程运行开始!
循环中子线程李元霸运行 : 0
李渊 线程运行开始!
循环中子线程李渊运行 : 0
循环中子线程李元霸运行 : 1
循环中子线程李渊运行 : 1
循环中子线程李元霸运行 : 2
循环中子线程李渊运行 : 2
循环中子线程李渊运行 : 3
循环中子线程李渊运行 : 4
循环中子线程李元霸运行 : 3
李渊 线程运行结束!
循环中子线程李元霸运行 : 4
李元霸 线程运行结束!
main主线程运行结束!

主线程一定会等子线程都结束了才结束

5）线程控制之线程礼让==让多个线程的执行更和谐，但是不能靠它保证一人一次

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。

package cn.itcast_04;

public class ThreadYield extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 20; x++) {
			System.out.println(getName() + ":" + x);
			// 当i为10时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
			if(x==10){
				Thread.yield();
			}
			
		}
	}
}
测试类： 
package cn.itcast_04;

/*
 * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。 
 * 让多个线程的执行更和谐，但是不能靠它保证一人一次。
 */
public class ThreadYieldDemo {
	public static void main(String[] args) {
		ThreadYield ty1 = new ThreadYield();
		ThreadYield ty2 = new ThreadYield();

		ty1.setName("轩辕");
		ty2.setName("花狐貂");

		ty1.start();
		ty2.start();
	}
}

运行结果(每次结果可能不一样):

第一种情况：轩辕（线程）当执行到10时会CPU时间让掉，这时花狐貂（线程）抢到CPU时间并执行

第二种情况：花狐貂（线程）当执行到10时会CPU时间让掉，这时轩辕（线程）抢到CPU时间并执行。

花狐貂:0
花狐貂:1
花狐貂:2
花狐貂:3
花狐貂:4
花狐貂:5
花狐貂:6
花狐貂:7
花狐貂:8
花狐貂:9
花狐貂:10
轩辕:0
轩辕:1
轩辕:2
轩辕:3
轩辕:4
轩辕:5
轩辕:6
轩辕:7
轩辕:8
轩辕:9
轩辕:10
轩辕:11
轩辕:12
花狐貂:11
花狐貂:12
花狐貂:13
轩辕:13
轩辕:14
轩辕:15
轩辕:16
轩辕:17
轩辕:18
轩辕:19
花狐貂:14
花狐貂:15
花狐貂:16
花狐貂:17
花狐貂:18
花狐貂:19
总结： sleep()和yield()的区别：sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

6）线程控制之守护线程

public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。

package cn.itcast_04;

public class ThreadDaemon extends Thread {
	@Override
	public void run() {
		for (int x = 0; x < 10; x++) {
			System.out.println(getName() + ":" + x);
		}
	}
}

测试类：

package cn.itcast_04;

/*
 * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
 * 当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。 
 * 
 * 游戏：坦克大战。
 */
public class ThreadDaemonDemo {
	public static void main(String[] args) {
		ThreadDaemon td1 = new ThreadDaemon();
		ThreadDaemon td2 = new ThreadDaemon();

		td1.setName("关羽");
		td2.setName("张飞");

		// 设置收获线程
		td1.setDaemon(true);
		td2.setDaemon(true);

		td1.start();
		td2.start();

		Thread.currentThread().setName("刘备");
		for (int x = 0; x < 5; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}
}
7）线程控制之线程中断

public final void stop():让线程停止，过时了，但是还可以使用。

public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。

如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。

如果以前的条件都没有保存，则该线程的中断状态将被设置。

中断一个不处于活动状态的线程不需要任何作用。


抛出：
SecurityException - 如果当前线程无法修改该线程 

package cn.itcast_04;

import java.util.Date;

public class ThreadStop extends Thread {
	@Override
	public void run() {
		System.out.println("开始执行：" + new Date());

		// 我要休息10秒钟，亲，不要打扰我哦
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// e.printStackTrace();
			System.out.println("线程被终止了");
		}

		System.out.println("结束执行：" + new Date());
	}
}

测试类：

package cn.itcast_04;

/*
 * public final void stop():让线程停止，过时了，但是还可以使用。
 * public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。
 */
public class ThreadStopDemo {
	public static void main(String[] args) {
		ThreadStop ts = new ThreadStop();
		ts.start();

		// 你超过三秒不醒过来，我就干死你
		try {
			Thread.sleep(3000);
			// ts.stop();
			ts.interrupt();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

运行结果：

开始执行：Mon Apr 16 16:02:02 CST 2018
线程被终止了
结束执行：Mon Apr 16 16:02:10 CST 2018
线程的消亡不能通过调用stop()命令，而是让run()方法自然结束。stop()方法是不安全的，已经废弃。

停止线程推荐的方式：设定一个标志变量，在run()方法中是一个循环，由该标志变量控制循环是继续执行还是跳出；循环跳出，则线程结束。

二、ThreadLocal

2.1 ThreadLocal的认识与理解

ThreadLocal翻译成中文比较准确的叫法应该是：线程局部变量。很多地方叫做线程本地变量，也有些地方叫做线程本地存储。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

在并发编程的时候，成员变量如果不做任何处理其实是线程不安全的，各个线程都在操作同一个变量，显然是不行的，并且我们也知道volatile这个关键字也是不能保证线程安全的。那么在有一种情况之下，我们需要满足这样一个条件：变量是同一个，但是每个线程都使用同一个初始值，也就是使用同一个变量的一个新的副本。这种情况之下ThreadLocal就非常使用，比如说DAO的数据库连接，我们知道DAO是单例的，那么他的属性Connection就不是一个线程安全的变量。而我们每个线程都需要使用他，并且各自使用各自的。这种情况，ThreadLocal就比较好的解决了这个问题。

如：

class ConnectionManager {
     
    private static Connection connect = null;
     
    public static Connection openConnection() {
        if(connect == null){
            connect = DriverManager.getConnection();
        }
        return connect;
    }
     
    public static void closeConnection() {
        if(connect!=null)
            connect.close();
    }
}

        假设有这样一个数据库链接管理类，这段代码在单线程中使用是没有任何问题的，但是如果在多线程中使用呢？很显然，在多线程中使用会存在线程安全问题：第一，这里面的2个方法都没有进行同步，很可能在openConnection方法中会多次创建connect；第二，由于connect是共享变量，那么必然在调用connect的地方需要使用到同步来保障线程安全，因为很可能一个线程在使用connect进行数据库操作，而另外一个线程调用closeConnection关闭链接。

        所以出于线程安全的考虑，必须将这段代码的两个方法进行同步处理，并且在调用connect的地方需要进行同步处理。这样将会大大影响程序执行效率，因为一个线程在使用connect进行数据库操作的时候，其他线程只有等待。

分析一下这个问题，这地方到底需不需要将connect变量进行共享？事实上，是不需要的。假如每个线程中都有一个connect变量，各个线程之间对connect变量的访问实际上是没有依赖关系的，即一个线程不需要关心其他线程是否对这个connect进行了修改的。　　

        既然不需要在线程之间共享这个变量，可以直接这样处理，在每个需要使用数据库连接的方法中具体使用时才创建数据库链接，然后在方法调用完毕再释放这个连接。

class ConnectionManager {
     
    private static Connection connect = null;
     
    public static Connection openConnection() {
        if(connect == null){
            connect = DriverManager.getConnection();
        }
        return connect;
    }
     
    public static void closeConnection() {
        if(connect!=null)
            connect.close();
    }
}

class ConnectionManager {
     
    private  Connection connect = null;
     
    public Connection openConnection() {
        if(connect == null){
            connect = DriverManager.getConnection();
        }
        return connect;
    }
     
    public void closeConnection() {
        if(connect!=null)
            connect.close();
    }
}
 
 
class Dao{
    public void insert() {
        ConnectionManager connectionManager = new ConnectionManager();
        Connection connection = connectionManager.openConnection();
         
        //使用connection进行操作
         
        connectionManager.closeConnection();
    }
}

这样处理确实也没有任何问题，由于每次都是在方法内部创建的连接，那么线程之间自然不存在线程安全问题。但是这样会有一个致命的影响：导致服务器压力非常大，并且严重影响程序执行性能。由于在方法中需要频繁地开启和关闭数据库连接，这样不尽严重影响程序执行效率，还可能导致服务器压力巨大。

虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

2.2 ThreadLocal类源码解读

package java.lang;
import java.lang.ref.*;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;


public class ThreadLocal {
    /**
     * ThreadLocal将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode,	 
     * ThreadLocal实例hash值，用来区分不同实例
     * 	 
     */
    private final int threadLocalHashCode = nextHashCode();
	
    /**
     * 可以看作hash值的一个基值
     */
    private static AtomicInteger nextHashCode =new AtomicInteger();
        
    /**
     *hash值每次增加量  
     */
    
    private static final int HASH_INCREMENT = 0x61c88647;
    /**
     * 
     */
    
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    /**
     * 初始化函数
     * 此方法在每个线程中最多执行一次，如果第一次执行get()，会调用此方法
     * 如果在第一次执行get()之前已经调用过set()，则此方法永远不执行
     * 可以看到默认返回null值，为了避免不必要错误，最好重写此方法     
	 */
    protected T initialValue() {
        return null;
    }

    /**
     * Creates a thread local variable. The initial value of the variable is
     * determined by invoking the {@code get} method on the {@code Supplier}.
     *
     * @param  the type of the thread local's value
     * @param supplier the supplier to be used to determine the initial value
     * @return a new thread local variable
     * @throws NullPointerException if the specified supplier is null
     * @since 1.8
     */
    public static  ThreadLocal withInitial(Supplier supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }

    /**
     * 无参构造函数
     */
    public ThreadLocal() {
    }

    /**
     *
     * 获取线程所属的值
     */
    public T get() {
		//得到当前线程
        Thread t = Thread.currentThread();
		//得到当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
		//如果map不为null
        if (map != null) {
		    //得到map中Entry实体对象
            ThreadLocalMap.Entry e = map.getEntry(this);
			//如果e不为空，则取出Entry对象中的value值，然后返回 
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
		//在没有map或map中没有添加该ThreadLocal时,则创建ThreadLocalMap对象,并且创建一个空的T对象放到map中，最后返回null
        return setInitialValue();
    }

    /**
     * 初始化.
     *
     * @return the initial value
     */
    private T setInitialValue() {
		//初始化函数,返回null
        T value = initialValue();
		//得到当前线程
        Thread t = Thread.currentThread();
		//得到当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
		//map不为空，则将value放到map
        if (map != null)
            map.set(this, value);
		//否则如果Thread中并没有map，则新建一个,然后将value放到map中，这里注意,是每个Thread维护一个ThreadLocalMap	
        else 
            createMap(t, value);
        return value;
    }

    /**
     * 把value放到当前线程的ThreadLocalMap对象中去，其中key值与当前ThreadLocal对象的threadLocalHashCode值有关
     *
     * 
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
			//这里同样有可能调用创建ThreadLocalMap
            createMap(t, value);
    }

    /**
     * 
     * 
     * 
     *删除当前线程的 ThreadLocalMap对象中 key为当前ThreadLocal 的Entry(包含key/value)
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

    /**
     *  取得TheadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    /**
     *创建TheadLocalMap
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    /**
     * Factory method to create map of inherited thread locals.
     * Designed to be called only from Thread constructor.
     *
     * @param  parentMap the map associated with parent thread
     * @return a map containing the parent's inheritable bindings
     */
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

    /**
     * Method childValue is visibly defined in subclass
     * InheritableThreadLocal, but is internally defined here for the
     * sake of providing createInheritedMap factory method without
     * needing to subclass the map class in InheritableThreadLocal.
     * This technique is preferable to the alternative of embedding
     * instanceof tests in methods.
     */
    T childValue(T parentValue) {
        throw new UnsupportedOperationException();
    }

    /**
     * SuppliedThreadLocal是JDK8新增的内部类，只是扩展了ThreadLocal的初始化值的方法而已，允许使用JDK8新增的Lambda表达式赋值。
     * 需要注意的是，函数式接口Supplier不允许为null
     */
    static final class SuppliedThreadLocal extends ThreadLocal {

        private final Supplier supplier;

        SuppliedThreadLocal(Supplier supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

    /**
     * 静态内部类ThreadLcoalMap 用来存储每个线程的局部变量 
     */
    static class ThreadLocalMap {

        /**
         * Entry继承自WeakReference类，是存储线程私有变量的数据结构
         * ThreadLocal实例作为引用，意味着如果ThreadLocal实例为null
         * 就可以从table中删除对应的Entry
         */
        static class Entry extends WeakReference> {
            /** 把ThreadLocal与value封装成Entry*/
            Object value;
            /** 把ThreadLocal与value封装成Entry*/		
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * 数组初始容量为16
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 存储数组,数组的长度必须是2^
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * 数组的初始化大小
         */
        private int size = 0;

        /** 
         * 临界值加载因子默认为0
         */
        private int threshold; 

        /**
         * 设置 临界值setThreshold
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        /**
         * 从i递增到len
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * 从i递减到1的过程,返回i-1，当i<1返回len-1
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

        /**
         * 构造函数.
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        /**
         * Construct a new map including all Inheritable ThreadLocals
         * from given parent map. Called only by createInheritedMap.
         *
         * @param parentMap the map associated with parent thread.
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal key = (ThreadLocal) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

        /**
         * Get the entry associated with key.  This method
         * itself handles only the fast path: a direct hit of existing
         * key. It otherwise relays to getEntryAfterMiss.  This is
         * designed to maximize performance for direct hits, in part
         * by making this method readily inlinable.
         *
         * @param  key the thread local object
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

        /**
         * Version of getEntry method for use when key is not found in
         * its direct hash slot.
         *
         * @param  key the thread local object
         * @param  i the table index for key's hash code
         * @param  e the entry at table[i]
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

        /**
         * 通过set方法往里面塞值
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
			// 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
            int i = key.threadLocalHashCode & (len-1);
            // 使用线性探测法查找元素
            for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
                 

                ThreadLocal k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
                if (k == key) {
                    e.value = value;
                    return;
                }
            //key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，当前数组中的 Entry 是一个陈旧（stale）的元素
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

        /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

        /**
         * Replace a stale entry encountered during a set operation
         * with an entry for the specified key.  The value passed in
         * the value parameter is stored in the entry, whether or not
         * an entry already exists for the specified key.
         *
         * As a side effect, this method expunges all stale entries in the
         * "run" containing the stale entry.  (A run is a sequence of entries
         * between two null slots.)
         *
         * @param  key the key
         * @param  value the value to be associated with key
         * @param  staleSlot index of the first stale entry encountered while
         *         searching for key.
         */
        private void replaceStaleEntry(ThreadLocal key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            
            int slotToExpunge = staleSlot;
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;

           
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal k = e.get();

               
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }


                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

           
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

        /**
         * Expunge a stale entry by rehashing any possibly colliding entries
         * lying between staleSlot and the next null slot.  This also expunges
         * any other stale entries encountered before the trailing null.  See
         * Knuth, Section 6.4
         *
         * @param staleSlot index of slot known to have null key
         * @return the index of the next null slot after staleSlot
         * (all between staleSlot and this slot will have been checked
         * for expunging).
         */
        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
                ThreadLocal k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

        /**
         * Heuristically scan some cells looking for stale entries.
         * This is invoked when either a new element is added, or
         * another stale one has been expunged. It performs a
         * logarithmic number of scans, as a balance between no
         * scanning (fast but retains garbage) and a number of scans
         * proportional to number of elements, that would find all
         * garbage but would cause some insertions to take O(n) time.
         *
         * @param i a position known NOT to hold a stale entry. The
         * scan starts at the element after i.
         *
         * @param n scan control: {@code log2(n)} cells are scanned,
         * unless a stale entry is found, in which case
         * {@code log2(table.length)-1} additional cells are scanned.
         * When called from insertions, this parameter is the number
         * of elements, but when from replaceStaleEntry, it is the
         * table length. (Note: all this could be changed to be either
         * more or less aggressive by weighting n instead of just
         * using straight log n. But this version is simple, fast, and
         * seems to work well.)
         *
         * @return true if any stale entries have been removed.
         */
        private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }

        /**
         * R当前的存储的对象个数是否已经超出了阈值（threshold的值）大小，如果超出了，需要重新扩充并将所有的对象重新计算位置（rehash函数来实现）
         */
        private void rehash() {
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                resize();
        }

        /**
         * Double the capacity of the table.
         */
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
			//ThreadLocalMap的初始长度为16，每次扩容都增长为原来的2倍，即它的长度始终是2的n次方
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

        /**
         * Expunge all stale entries in the table.
         */
        private void expungeStaleEntries() {
            Entry[] tab = table;
            int len = tab.length;
            for (int j = 0; j < len; j++) {
                Entry e = tab[j];
                if (e != null && e.get() == null)
                    expungeStaleEntry(j);
            }
        }
    }
}
 
  
 
  

 
  
多线程编程（三）--Thread常用方法以及ThreadLocal_第1张图片
 
  
Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。每个线程在往某个ThreadLocal里塞值的时候，都会往自己的ThreadLocalMap里存，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。
 
  

 
  
多线程编程（三）--Thread常用方法以及ThreadLocal_第2张图片
 
  
jdk文档里给出了四个普通方法和一个构造方法，我们依次来学习。
 
  
2.3.1 ThreadLocal构造方法
 
  
    /**
     * 无参构造函数
     */
    public ThreadLocal() {
    }

 
  
2.3.2 ThreadLocal普通方法-initialValue方法
 
  
    /**
     * 初始化函数
     * 此方法在每个线程中最多执行一次，如果第一次执行get()，会调用此方法
     * 如果在第一次执行get()之前已经调用过set()，则此方法永远不执行
     * 可以看到默认返回null值，为了避免不必要错误，最好重写此方法     
	 */
    protected T initialValue() {
        return null;
    }
 
  
2.3.4ThreadLocal普通方法--set(T value)方法
 
  
    /**
     * 把value放到当前线程的ThreadLocalMap对象中去，其中key值与当前ThreadLocal对象的threadLocalHashCode值有关
     *
     * 
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
			//这里同样有可能调用创建ThreadLocalMap
            createMap(t, value);
    }
 
  
1）ThreadLocalMap----静态内部类ThreadLcoalMap 用来存储每个线程的局部变量
 
  
   /**
     * 静态内部类ThreadLcoalMap 用来存储每个线程的局部变量 
     */
    static class ThreadLocalMap {

        /**
         * Entry继承自WeakReference类，是存储线程私有变量的数据结构
         * ThreadLocal实例作为引用，意味着如果ThreadLocal实例为null
         * 就可以从table中删除对应的Entry
         */
        static class Entry extends WeakReference> {

            Object value;
            /** 把ThreadLocal与value封装成Entry*/		
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * 数组初始容量为16
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 存储数组,数组的长度必须是2^
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * 数组的初始化大小
         */
        private int size = 0;

        /**
         * 默认为0
         */
        private int threshold; 

        /**
         * 设置setThreshold
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        /**
         * Increment i modulo len.
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * Decrement i modulo len.
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

        /**
         * 构造函数.
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        /**
         * Construct a new map including all Inheritable ThreadLocals
         * from given parent map. Called only by createInheritedMap.
         *
         * @param parentMap the map associated with parent thread.
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal key = (ThreadLocal) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

        /**
         * Get the entry associated with key.  This method
         * itself handles only the fast path: a direct hit of existing
         * key. It otherwise relays to getEntryAfterMiss.  This is
         * designed to maximize performance for direct hits, in part
         * by making this method readily inlinable.
         *
         * @param  key the thread local object
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

        /**
         * Version of getEntry method for use when key is not found in
         * its direct hash slot.
         *
         * @param  key the thread local object
         * @param  i the table index for key's hash code
         * @param  e the entry at table[i]
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

        /**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
			// 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
            int i = key.threadLocalHashCode & (len-1);
            // 使用线性探测法查找元素
            for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
                 

                ThreadLocal k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
                if (k == key) {
                    e.value = value;
                    return;
                }
            //key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，当前数组中的 Entry 是一个陈旧（stale）的元素
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

        /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

        /**
         * Replace a stale entry encountered during a set operation
         * with an entry for the specified key.  The value passed in
         * the value parameter is stored in the entry, whether or not
         * an entry already exists for the specified key.
         *
         * As a side effect, this method expunges all stale entries in the
         * "run" containing the stale entry.  (A run is a sequence of entries
         * between two null slots.)
         *
         * @param  key the key
         * @param  value the value to be associated with key
         * @param  staleSlot index of the first stale entry encountered while
         *         searching for key.
         */
        private void replaceStaleEntry(ThreadLocal key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            // Back up to check for prior stale entry in current run.
            // We clean out whole runs at a time to avoid continual
            // incremental rehashing due to garbage collector freeing
            // up refs in bunches (i.e., whenever the collector runs).
            int slotToExpunge = staleSlot;
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;

            // Find either the key or trailing null slot of run, whichever
            // occurs first
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal k = e.get();

                // If we find key, then we need to swap it
                // with the stale entry to maintain hash table order.
                // The newly stale slot, or any other stale slot
                // encountered above it, can then be sent to expungeStaleEntry
                // to remove or rehash all of the other entries in run.
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    // Start expunge at preceding stale entry if it exists
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }

                // If we didn't find stale entry on backward scan, the
                // first stale entry seen while scanning for key is the
                // first still present in the run.
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

            // If key not found, put new entry in stale slot
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            // If there are any other stale entries in run, expunge them
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

        /**
         * Expunge a stale entry by rehashing any possibly colliding entries
         * lying between staleSlot and the next null slot.  This also expunges
         * any other stale entries encountered before the trailing null.  See
         * Knuth, Section 6.4
         *
         * @param staleSlot index of slot known to have null key
         * @return the index of the next null slot after staleSlot
         * (all between staleSlot and this slot will have been checked
         * for expunging).
         */
        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

        /**
         * Heuristically scan some cells looking for stale entries.
         * This is invoked when either a new element is added, or
         * another stale one has been expunged. It performs a
         * logarithmic number of scans, as a balance between no
         * scanning (fast but retains garbage) and a number of scans
         * proportional to number of elements, that would find all
         * garbage but would cause some insertions to take O(n) time.
         *
         * @param i a position known NOT to hold a stale entry. The
         * scan starts at the element after i.
         *
         * @param n scan control: {@code log2(n)} cells are scanned,
         * unless a stale entry is found, in which case
         * {@code log2(table.length)-1} additional cells are scanned.
         * When called from insertions, this parameter is the number
         * of elements, but when from replaceStaleEntry, it is the
         * table length. (Note: all this could be changed to be either
         * more or less aggressive by weighting n instead of just
         * using straight log n. But this version is simple, fast, and
         * seems to work well.)
         *
         * @return true if any stale entries have been removed.
         */
        private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }

        /**
         * Re-pack and/or re-size the table. First scan the entire
         * table removing stale entries. If this doesn't sufficiently
         * shrink the size of the table, double the table size.
         */
        private void rehash() {
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                resize();
        }

        /**
         * Double the capacity of the table.
         */
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
			//ThreadLocalMap的初始长度为16，每次扩容都增长为原来的2倍，即它的长度始终是2的n次方
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

        /**
         * Expunge all stale entries in the table.
         */
        private void expungeStaleEntries() {
            Entry[] tab = table;
            int len = tab.length;
            for (int j = 0; j < len; j++) {
                Entry e = tab[j];
                if (e != null && e.get() == null)
                    expungeStaleEntry(j);
            }
        }
    } 
  
1.1) Entry对象与Entry数组
 
  
        /**
         * Entry继承自WeakReference类，是存储线程私有变量的数据结构
         * ThreadLocal实例作为引用，意味着如果ThreadLocal实例为null
         * 就可以从table中删除对应的Entry
         */
        static class Entry extends WeakReference> {
            /** 把ThreadLocal与value封装成Entry*/
            Object value;
            /** 把ThreadLocal与value封装成Entry*/		
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
 
  
        /**
         * 存储数组,数组的长度必须是2^
         * table.length MUST always be a power of two.
         */
        private Entry[] table;
 
  
从源码可以看出ThreadLocalMap存储的是ThreadLocalMap.Entry对象。也就是说ThreadLocalMap的大部分方法实际上都是对Entry的操作。ThreadLocalMap维护一张哈希表（一个数组），里面存的是Entry对象。从hashMap的源码我们知道既然是哈希表，那肯定就会涉及到加载因子，即当表里面存储的对象达到容量的多少百分比的时候需要扩容。ThreadLocalMap中定义了threshold属性，当表里存储的对象数量超过threshold就会扩容。
 
  
        /** 
         * 临界值加载因子默认为0
         */
        private int threshold; 

 
  
        /**
         * 设置 临界值setThreshold
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

 
  
 
  
如上源码加载因子设置为2/3。即每次容量超过设定的len的2/3时，需要扩容
 
  
1.2）ThreadLocalMap的初始化
 
  
        /**
         * 构造函数.
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }
 
  
        /**
         * Construct a new map including all Inheritable ThreadLocals
         * from given parent map. Called only by createInheritedMap.
         *
         * @param parentMap the map associated with parent thread.
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            setThreshold(len);
            table = new Entry[len];

            for (int j = 0; j < len; j++) {
                Entry e = parentTable[j];
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal key = (ThreadLocal) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }
它首先创建一个大小为16的实体数组，然后将threadLocalHashCode 和（length-1）进行与操作从而求得index，这个操作与threadLocalHashCode %length相等，之所以用与操作是因为更快。 
  
获取到index之后，就把这第一个值存入数组。 
  
至于设置的threshold ，其实就是代表着可用的length，如果超过了这个值，就会执行扩容操作。 
  
 
  
 
  
1.3）set(ThreadLocal key, Object value)方法
 
  
        /**
         * 通过set方法往里面塞值
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;
            int len = tab.length;
	   // 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
            int i = key.threadLocalHashCode & (len-1);
            // 使用线性探测法查找元素
            for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
                if (k == key) {
                    e.value = value;
                    return;
                }
            //key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，当前数组中的 Entry 是一个陈旧（stale）的元素
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
     
 
  
 
  
        private void replaceStaleEntry(ThreadLocal key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            
            int slotToExpunge = staleSlot;
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;

           
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal k = e.get();

               
                if (k == key) {
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;

                    
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }


                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }

           
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }
 
  

 
  
        private boolean cleanSomeSlots(int i, int n) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }
 
  
 
  

 
  

 
  
        /**
         * 从i递增到len
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }
 
  
 
  

 
  
这里有一个循环，index会一直执行加1操作（但是小于length），有三种情况会停止：
 
  
     
   
  1. 该位置的Entry为空，那么就用key和value新建一个Entry赋值到这个位置 
    2.  
   
  2. 到该位置的ThreadLocal为null，替换这个废弃的Entry。（一般情况就是由于弱引用被垃圾回收机制回收了）
    3.  
   
  3. 到该位置的ThreadLocal等于我们要赋值的ThreadLocal，直接使用value覆盖那个值
    4.  
  
 
  
从上面的代码看出通过key的hashCode来计算存储的索引位置i.如果i位置已经存储了对象，那么就往后挪一个位置依次类推，直到找到空的位置，再将对象存放。另外，在最后还需要判断一下当前的存储的对象个数是否已经超出了阈值（threshold的值）大小，如果超出了，需要重新扩充并将所有的对象重新计算位置（rehash函数来实现）。
 
  
rehash的原理是：int h = k.threadLocalHashCode & (len - 1); h!=i，表明当初在新增的时候，就发生了hash冲突，导致该entry在table的位置后移。处理方式是：将tab[i]=null，重新找index为h及之后的table，直道找到table[h]=null，然后将table[h] = e。
 
  
        /**
         * R当前的存储的对象个数是否已经超出了阈值（threshold的值）大小，如果超出了，需要重新扩充并将所有的对象重新计算位置（rehash函数来实现）
         */
        private void rehash() {
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                resize();
        }
 
  
        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
                ThreadLocal k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

 
  
 
  
rehash函数里面先调用了expungeStaleEntry方法，然后再判断当前存储对象的大小是否超出了阈值的3/4.ThreadLocalMap里面存储的Entry对象本质上是一个WeakReference>.也就是说里面存储的对象本质是一个对ThreadLocal对象的弱引用，该ThreadLocal随时可能会被回收！ThreadLocalMap里面对应的value的key是null.我们需要把这样的Entry对象清除掉。
 
  
resize()
 
  
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
	//ThreadLocalMap的初始长度为16，每次扩容都增长为原来的2倍，即它的长度始终是2的n次方
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }
将新的table大小设为旧的table大小的2倍。然后将旧的table中entry挨个插入到新的table中，当然，插入前还是要判断entry是否过期。 
  
插入过程中，如果发现hash冲突（int h = k.threadLocalHashCode & (newLen - 1); ），则查找h之后的table元素，知道table[h] != null，将table[h] = e； 
  
 
  

 
  
ThreadLocal之get流程
 
  
a)根据hashCode和数组长度计算元素放置的位置即数组下表
 
  
b)根据a得到的数组下标开始往后遍历，如果key相等则覆盖Value,如果key为null,则用新的key和value覆盖，同时清除历史key=null的数据
 
  
c)如果超过阈（yu\）值,就需要再哈希：
 
  
   c1. 清理一遍陈旧数据
 
  
 c2. >=3/4的阈值就需要执行扩容，就把table扩容为两倍
 
  
c3. 把老数据从新哈希进去新的table
 
  
2.3.5)ThreadLocal普通方法-get()方法
 
  
    /**
     *
     * 获取线程所属的值
     */
    public T get() {
		//得到当前线程
        Thread t = Thread.currentThread();
	//得到当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
		//如果map不为null
        if (map != null) {
		//得到map中Entry实体对象
            ThreadLocalMap.Entry e = map.getEntry(this);
	  //如果e不为空，则取出Entry对象中的value值，然后返回 
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
	//在没有map或map中没有添加该ThreadLocal时,则创建ThreadLocalMap对象,并且创建一个空的T对象放到map中，最后返回null
        return setInitialValue();
    }
 
  

 
  
    /**
     *  取得TheadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
 
  
        private Entry getEntry(ThreadLocal key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }
 
  

 
  
        private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal k = e.get();
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
 
  

 
  
        private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {
                ThreadLocal k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

 
  

 
  
getMap(t)返回当前线程的成员变量ThreadLocalMap（Thread的成员变量有ThreadLocalMap，这一点可以查看Thread的源码，如下）很明确的说明了ThreadLocal属于线程，ThreadLocalMap由ThreadLocal持有，说到底，ThreadLocalMap 也是线程所持有。每个线程Thread都有自己的ThreadLocalMap。
 
  
没有设值，所以map 为空，直接回调setInitialValue()，若事先有设值，且map不为空，通过map.getEntry(this)将ThreadLocal对象作为key传入。
 
  
先通过 key.threadLocalHashCode & (table.length - 1) 运算得到Entry的索引 i，再通过table[i]得到Entry e进行判断,如果e不为空，则通过e.get()拿出entry里面的key和传入的key比较，若相等，直接返回e,否则回调getEntryAfterMiss(key, i, e)。
 
  
ThreadLocal之get流程
 
  
a)获取当前线程t；
 
  
b)返回当前线程t的成员变量ThreadLocalMap（以下简写map）
 
  
c)map不为null，则获取以当前线程为key的ThreadLocalMap的Entry（以下简写e），如果e不为null，则直接返回该Entry的value
 
  
d)如果map为null或者e为null，返回setInitialValue()的值。setInitialValue()调用重写的initialValue()返回新值（如果没有重写initialValue将返回默认值null），并将新值存入当前线程的ThreadLocalMap（如果当前线程没有ThreadLocalMap，会先创建一个）
 
  
2.3.5)ThreadLocal普通方法-remove()方法
 
  

 
  
    /**
     * 
     * 
     * 
     *删除当前线程的 ThreadLocalMap对象中 key为当前ThreadLocal 的Entry(包含key/value)
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }
 
  
   /**
     *  取得TheadLocalMap 
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
 
  
 
  
ThreadLocalMap的remove方法
 
  
        /**
         * Remove the entry for key.
         */
        private void remove(ThreadLocal key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }
 
  
remove()移除当前线程的当前ThreadLocal数据（只是清空该key-value键值对），而且是立即移除，移除后，再调用get方法将重新调用initialValue方法初始化（除非在此期间调用了set方法赋值）
 
  

 
  

 
  
总结：
 
  
 
  
1）一个线程中的所有的局部变量其实存储在该线程自己的同一个map属性中；
 
  
2）线程死亡时，线程局部变量会自动回收内存；
 
  
3）线程局部变量时通过一个 Entry 保存在map中，该Entry 的key是一个 WeakReference包装的ThreadLocal, value为线程局部变量; 
 
  
     key 到 value 的映射是通过：ThreadLocal.threadLocalHashCode & (INITIAL_CAPACITY - 1) 来完成的；
 
  
4）当线程拥有的局部变量超过了容量的2/3(没有扩大容量时是10个)，会涉及到ThreadLocalMap中Entry的回收；
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java学习)

        

            

                
    
                    
  • 大学生入门：初识方法及其易踩坑的点
                        

                        
    在java学习过程中，我们不难发现有很多重复使用的功能代码块，每次使用如果都要重新写一遍，岂不是很麻烦，就算是“cv”大法，感觉也不是很方便，那么，有什么办法可以解决这个问题呢？方法！java中，一段可重用的，用于执行特定功能的代码块叫做方法，它可以接收参数、返回结果，并且可以被多次使用。一、方法的基本结构[修饰符]返回值类型方法名([参数列表])[throws异常类型]{//方法体}[throw
    
                    
    • 
                    
  • java学习笔记8
                        幸福，你等等我
学习笔记java
                        
    一、异常处理Error：错误，程序员无法处理，如OOM内存溢出错误、内存泄漏...会导出程序崩溃1.异常：程序中一些程序自身处理不了的特殊情况2.异常类Exception3.异常的分类:（1）.检查型异常(编译异常):在编译时就会抛出的异常(代码上会报错),需要在代码中编写处理方式(和程序之外的资源访问)直接继承Exception（2）.运行时异常:在代码运行阶段可能会出现的异常,可以不用明文处理
    
                    
    • 
                    
  • Java学习-----JVM的垃圾回收算法
                        

                        
    在Java虚拟机（即JVM）中，垃圾收集是自动内存管理的核心机制，其主要作用是识别并回收不再使用的对象所占用的内存空间，以避免内存泄漏和溢出。不同的垃圾收集算法有着不同的实现思路和适用场景，下面将详细介绍JVM中4种常见的垃圾收集算法。（一）标记-清除算法标记-清除算法是最基础的垃圾收集算法，它分为“标记”和“清除”两个阶段。在标记阶段，会遍历所有对象，标记出需要回收的垃圾对象；在清除阶段，会清除
    
                    
    • 
                    
  • java知识点分享篇（一）
                        微笑的小小刀

                        
    java分享篇一大家好，我是小小刀，我们又见面啦，本文是一个新的系列->java分享系列，现在有三个系列，java学习系列：一篇系统的讲一个知识点，java故事系列：散文随笔，有知识点也有生活。本篇是java分享系列第一篇：收集大家在学习交流群中的分享，并做简单的发散进学习交流群可加小刀微信：best396975802公众号:java技术大本营sql分页（小小刀）原分享sqlserver中的分页语
    
                    
    • 
                    
  • JAVA---继承与多态（基础详解与样例分析）
                        胡同巷的猫七姑娘~
javaeclipse开发语言
                        
    在JAVA学习有了一定基础和了解上将会继续深入学习多态，面向对象程序设计的三大支柱是封装、继承和多态，学习的步骤是循环渐进的，在学习了封装和继承的基础知识后进而了解多态。什么是多态？多态意味着父类型的变量可以引用子类型的对象，注意这句话中的几个关键点，是父类型的变量，去引用子类型的对象。接下来的学习中就是去解释和运用这句话。目录HINT1继承HINT2多态HINT1继承在引入多态之前，我们先再回顾
    
                    
    • 
                    
  • Java学习--------享元模式
                        

                        
    在软件开发中，当系统需要创建大量相似对象时，内存消耗会急剧增加，可能导致系统性能下降。享元模式正是为解决这一问题而生，它通过共享技术实现对象的复用，有效减少对象数量，降低内存占用，提升系统效率。享元模式是一种结构型设计模式，其核心思想是通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。这里的“享元”指的是可以被多个对象共享的单元。比如在一个文字
    
                    
    • 
                    
  • Java学习--------组合模式
                        典孝赢麻崩乐急
java学习组合模式
                        
    在软件开发中，经常会遇到处理由多个相似对象组成的树形结构的场景，比如文件系统中的文件和文件夹、公司的组织结构等。组合模式为这类问题提供了优雅的解决方案，它能够让客户端以统一的方式处理单个对象和对象组合。组合模式是一种结构型设计模式，其核心思想是将对象组合成树形结构以表示“部分-整体”的层次关系，使得客户端对单个对象和组合对象的使用具有一致性。简单来说，组合模式就是把多个简单的对象组合成一个复杂的对
    
                    
    • 
                    
  • Java学习--------策略模式
                        典孝赢麻崩乐急
java学习策略模式
                        
    在软件开发中，面对同一问题往往存在多种解决方案，且这些方案可能需要根据不同场景动态切换。策略模式为这种场景提供了优雅的解决方案，它能让算法或行为在不影响客户端的情况下灵活替换。策略模式是一种行为型设计模式，其核心思想是定义一系列算法，将每个算法封装起来，并使它们可以相互替换，让算法的变化独立于使用算法的客户端。简单来说，策略模式就是把做一件事的不同方法（策略）分开封装，使得这些方法可以互相替换，而
    
                    
    • 
                    
  • Java学习----原型模式
                        典孝赢麻崩乐急
java学习原型模式
                        
    在软件开发中，创建对象往往需要经过复杂的初始化过程，比如读取配置文件、连接数据库获取数据等。如果频繁创建此类对象，会消耗大量系统资源，影响程序性能。原型模式作为一种创建型设计模式，为解决这一问题提供了高效方案。原型模式是指用一个已经创建的实例作为原型，通过复制该原型来创建一个和原型相同或相似的新对象。简单来说，就是通过复制现有对象来生成新对象，而不是通过new关键字重新创建。这种模式的核心在于“复
    
                    
    • 
                    
  • Java学习-------外观模式
                        典孝赢麻崩乐急
java学习外观模式
                        
    在软件开发中，随着系统的不断迭代，模块会越来越多，模块之间的依赖关系也会变得错综复杂。这不仅会增加开发难度，还会让系统的维护和扩展变得棘手。而外观模式就像一位“前台接待员”，为复杂的系统提供一个简洁统一的接口，让外部与系统的交互变得简单高效。。外观模式是设计模式三大类中的一种结构型设计模式，它为子系统中的一组接口提供一个统一的高层接口，使得子系统更容易被使用。简单来说，就是在复杂的子系统外面套上一
    
                    
    • 
                    
  • Java学习第七十五部分——Docker
                        慕y274
java学习docker
                        
    目录一、前言提要⚙️二、核心概念️三、核心技术⚖️四、与传统虚拟机的区别五、核心优势六、应用场景⚙️七、核心价值——对于Java开发️八、Java应用容器化核心步骤⚖️九、构建Java镜像的三种方式对比十、容器生命周期管理十一、环境最佳实践十二、总结归纳概述一、前言提要Docker是一个开源的容器化平台，允许开发者将应用程序及其依赖环境（如代码、运行时环境、系统工具、配置文件等）打包成一个轻量级、
    
                    
    • 
                    
  • Java学习第七十六部分——Java内存模型 (JMM)
                        

                        
    目录一、前言概述提要二、关键作用解释三、核心概念剖析四、问题解决方案五、happens-before原则六、总结归纳升华一、前言概述提要Java内存模型(JavaMemoryModel,JMM)是Java虚拟机(JVM)规范中定义的一个核心概念，它规定了多线程环境下，线程如何与主内存交互以及线程之间如何通过主内存共享变量。它的主要目的是解决多线程编程中常见的三大核心问题：可见性、有序性、原子性。二
    
                    
    • 
                    
  • Java学习第六十三部分——K8s
                        

                        
    目录一、关键概述二、定义起源三、核心特点️四、核心组件五、资源对象⚡六、应用场景七、Java与K8s️八、运维与监控九、总结与归纳一、关键概述Kubernetes（简称K8s，源自“K”与“s”之间的8个字母）是开源的容器编排平台，由Google团队基于其内部Borg系统设计理念开源，现已成为云原生应用管理的事实标准。Java与K8s的结合是云原生应用开发的核心实践，帮助Java开发者高效管理容器
    
                    
    • 
                    
  • 9：java学习笔记：do-while语句
                        Charles Wesley（范清远）
java学习java笔记eclipse
                        
    do-while也是一种循环语句，与while很像，但是与while刚刚好反一下。9.1do-while的基本结构do{//循环体：要执行的代码}while(条件);do--while是先循环，再判断条件，就是先执行代码，然后呢判断条件，循环体先执行一次；然后判断条件；如果条件为true，再重复执行；如果条件为false，就退出。这个结构刚刚好和while循环的结构是相反的。注意！！while(条
    
                    
    • 
                    
  • 2025 版 Java 学习路线实战指南从入门到精通全程解析
                        

                        
    Java学习路线实战指南（2025版）一、基础环境搭建（2025最新）JDK安装：推荐使用LibericaJDK21LTS（支持GraalVM原生编译）#macOS使用SDKMAN安装curl-s"https://get.sdkman.io"|bashsource"$HOME/.sdkman/bin/sdkman-init.sh"sdkinstalljava21.0.1-librca#Window
    
                    
    • 
                    
  • 《Java学习大冒险：从菜鸟到“大侠”之路》05
                        

                        
    《Java学习大冒险：从菜鸟到“大侠”之路》——异常详解篇嘿，各位怀揣着Java编程梦想的“小菜鸟”们！今天咱们就开启一场关于Java异常的奇妙大冒险，一起揭开异常这个“神秘小怪兽”的面纱，助你从Java菜鸟一路升级成为Java“大侠”！一、异常的“家族谱系”在Java的世界里，异常就像是一个大家族，有着清晰的“家族谱系”。Throwable是Java语言中所有错误与异常的超类，它就像是这个家族的
    
                    
    • 
                    
  • Java学习第七十部分——微服务架构
                        慕y274
java学习开发语言微服务
                        
    目录一、前言提要二、核心优势三、核心技术栈四、构建步骤五、困难挑战六、总结归纳一、前言提要Java微服务架构是一种使用Java技术栈构建分布式系统的方法论，它将单一的大型应用程序分解为一组小型、独立、松耦合、可独立部署和扩展的服务。每个服务专注于一个特定的业务能力，并通过轻量级通信机制（通常是HTTP/REST或异步消息）进行交互。二、核心优势1.服务独立独立开发：不同团队可以独立开发、测试和部署
    
                    
    • 
                    
  • Java学习第七十二部分——Zookeeper
                        慕y274
java-zookeeperjava学习
                        
    目录一、前言提要概述二、核心概念特性三、安装配置步骤四、内部工作原理五、典型应用场景六、常见问题解决七、总结归纳应用一、前言提要概述Zookeeper是一个开源的分布式协调服务，由Apache基金会维护，广泛应用于分布式系统中的配置管理、命名服务、集群管理、分布式锁等场景。二、核心概念特性定位与设计目标：分布式协调：解决分布式系统中的数据一致性、节点状态同步等问题，提供简单高效的协调机制。数据模型
    
                    
    • 
                    
  • Java学习第七十一部分——Dubbo
                        

                        
    目录一、前言提要二、核心特性三、架构组成四、工作流程五、代码示例——基于SpringBoot集成六、适用场景七、框架对比八、总结归纳一、前言提要ApacheDubbo是一个高性能、轻量级的开源JavaRPC框架，最初由阿里巴巴开发，2018年捐赠给Apache基金会，现为顶级项目。它主要用于构建分布式、微服务架构中的服务治理和通信，支持多种协议和注册中心，适用于高并发场景。二、核心特性1.RPC通
    
                    
    • 
                    
  • Java学习第六十六部分——分布式系统架构
                        慕y274
java学习架构
                        
    目录一、前言提要二、核心目标三、核心组件与技术1.服务拆分与通信2.服务注册与发现3.配置中心4.负载均衡5.熔断、降级与限流6.API网关7.分布式数据管理8.分布式追踪与监控9.容器化与编排四、典型Java分布式技术栈组合五、关键挑战与解决方案六、设计原则七、总结归纳一、前言提要Java分布式系统架构是一种利用多台计算机（节点）协同工作，共同完成单个计算机难以胜任的大型任务（高并发、大数据量、
    
                    
    • 
                    
  • Java学习----Redis集群
                        典孝赢麻崩乐急
java学习redis
                        
    在分布式系统开发中，Redis作为高性能的键值存储数据库，被广泛用于缓存、会话存储、消息队列等场景。当单节点Redis无法满足高并发、大容量的需求时，Redis集群成为解决性能瓶颈和数据可靠性问题的关键方案。Redis集群是Redis提供的分布式解决方案，通过将数据分片存储在多个节点上，实现数据的分布式存储和负载均衡。它由多个Redis节点组成，节点之间通过gossip协议进行通信，共同承担数据存
    
                    
    • 
                    
  • Java学习-----Bean
                        典孝赢麻崩乐急
java学习rpc
                        
    在Spring框架中，Bean是核心概念之一，它贯穿了整个Spring应用的生命周期，是实现依赖注入（DI）和控制反转（IoC）的基础。理解Bean的原理、作用及使用特点，对于掌握Spring框架至关重要。SpringBean的本质是由SpringIoC容器管理的对象，它的创建、初始化、依赖注入及销毁等过程均由容器控制，而非通过传统的new关键字手动创建。其核心原理可概括为以下两点：1.控制反转（
    
                    
    • 
                    
  • Java学习----NIO模型
                        典孝赢麻崩乐急
java学习nio
                        
    在Java的I/O模型中，NIO（Non-BlockingI/O，非阻塞I/O）是对BIO的重要改进。它为高并发场景提供了更高效的处理方式，在众多Java应用中发挥着关键作用。NIO模型的核心在于非阻塞和多路复用，其采用“一个线程处理多个连接”的模式，主要依靠通道（Channel）、缓冲区（Buffer）和选择器（Selector）这三个核心组件协同工作，每个核心组件的功能原理和功能如下：（1）通
    
                    
    • 
                    
  • Java学习————————ThreadLocal
                        典孝赢麻崩乐急
java学习开发语言
                        
    ThreadLocal是Java中一个非常重要的线程级别的变量隔离机制，它提供了线程局部变量，使得每个线程都可以拥有自己独立的变量副本，从而避免了多线程环境下的共享变量竞争问题。ThreadLocal的实现原理主要依赖于：（1）ThreadLocalMap：每个Thread对象内部都有一个ThreadLocalMap实例（2）弱引用键：ThreadLocalMap使用ThreadLocal对象作为
    
                    
    • 
                    
  • JAVA学习-行为抽象和Lambda.Lambda表达式
                        守护者170
java学习java学习开发语言
                        
    行为抽象和Lambda表达式是Java8引入的新特性，用于简化代码和提高代码的可读性。一、概述、特点、使用方法以及与其他比较和高级应用的说明：1.行为抽象：它是指将一段代码抽象为一种功能或行为，以便在需要时可以传递给其他方法或对象。行为抽象通常通过接口来定义，其中接口包含一个或多个抽象方法来表示不同的功能。2.Lambda表达式：Lambda表达式是一种简洁的语法，用于实现行为抽象。它可以替代匿名
    
                    
    • 
                    
  • JAVA API (三)：从基础爬虫构建到带条件数据提取 —— 详解 URL、正则与爬取策略
                        钮祜禄.爱因斯晨
JAVA学习笔记java爬虫开发语言
                        
    个人主页-爱因斯晨文章专栏-Java学习相关文章：API(一)相关文章：API（二）持续努力中，感谢支持一、爬虫基础（一）爬虫的基本概念定义：爬虫是按照一定规则自动抓取网络信息的程序，在Java环境下，可借助URL、HttpURLConnection等API来实现。应用场景：广泛应用于数据采集，如电商平台的价格监控、各类新闻的聚合；还可用于信息分析，如舆情监测等。（二）Java实现简单爬虫的步骤建
    
                    
    • 
                    
  • 最新Java学习路线总结，搬砖工逆袭Java架构师
                        2401_84266286
程序员java学习开发语言
                        
    |一文读懂JVM类加载机制过程及原理||跟同事杠上了，ApacheBeanutils为什么被禁止使用？||Java中常见的编码集问题||为什么人们宁可用Lombok，也不把成员设为public？|2、java集合【Java集合1】Java集合基础知识总结（绝对经典）【Java集合2】List遍历删除元素remove()")【Java集合3】List＜T＞和List＜?＞的区别【Java集合4】Ja
    
                    
    • 
                    
  • Java学习第五十八部分——设计模式
                        慕y274
java学习设计模式
                        
    目录一、概述提要二、创建型模式——解决“如何创建对象”的问题1.单例模式(Singleton)2.工厂方法模式(FactoryMethod)3.解释器模式(Interpreter)4.建造者模式(Builder)5.原型模式(Prototype)三、结构型模式——解决“如何组合类和对象”的问题1.适配器模式(Adapter)2.桥接模式(Bridge)3.组合模式(Composite)4.装饰器模
    
                    
    • 
                    
  • java学习day6 + leetcode31 下一个排列
                        冬夜戏雪
java学习算法
                        
    1.消息队列和一些功能P74P75P76基于stream的消息队列单消费模式消费者组P77基于消息队列的异步秒杀下单shift2提及，插入已知笔记P78探店笔记P79查看探店笔记p80点赞功能一人一赞这里也有并发P81点赞排行榜sortedsetset集合的选择redis里面的zsetmybatis改sql排序语句p82好友关注关注和取关p83共同关注redis里的set交集功能解析id集合没看懂
    
                    
    • 
                    
  • java学习 leetcode31 下一个排列
                        冬夜戏雪
java学习leetcode
                        
    1.排列方法（按照全排列，数组，整数来回转换的思路）packagecom.hmdp.leetcode;importjava.util.*;publicclassbacktracking31{publicvoidnextPermutation(int[]nums){//1.将当前数组转为字符串表示StringBuildersb=newStringBuilder();for(intnum:nums){
    
                    
    • 
                                
  • LeetCode[Math] - #66 Plus One
                                    Cwind
javaLeetCode题解AlgorithmMath
                                    
    原题链接：#66 Plus One 
  
要求： 
给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 
注意： 
1. 数字的较高位存在数组的头上，即num1表示数字1239 
2. 每一位（数组中的每个元素）的取值范围为0~9 
  
难度：简单 
  
分析： 
题目比较简单，只须从数组
    
                                
    • 
                                
  • JQuery中$.ajax()方法参数详解
                                    AILIKES
JavaScriptjsonpjqueryAjaxjson
                                    
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 
type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 
timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
    
                                
    • 
                                
  • JConsole & JVisualVM远程监视Webphere服务器JVM
                                    Kai_Ge
JVisualVMJConsoleWebphere
                                    
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 
　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 
　　首先我们看WAS服务器端的配置. 
　　1、登录was控制台https://10.4.119.18
    
                                
    • 
                                
  • 自定义annotation
                                    120153216
annotation
                                    
    Java annotation 自定义注释@interface的用法  一、什么是注释  
 
    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
    
                                
    • 
                                
  • CentOS 5/6.X 使用 EPEL YUM源
                                    2002wmj
centos
                                    
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
    
                                
    • 
                                
  • 在SQLSERVER中查找缺失和无用的索引SQL
                                    357029540
SQL Server
                                    
    --缺失的索引 
SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,  
        last_user_seek ,  
  
    
                                
    • 
                                
  • Spring3 MVC 笔记（二） —json+rest优化
                                    7454103
Spring3 MVC
                                    
    接上次的 spring mvc 注解的一些详细信息！ 
                         其实也是一些个人的学习笔记  呵呵！ 
 

    
                                
    • 
                                
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^
                                    adminjun
java“\替换”
                                    
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 
  
在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 
   
 
 public class Main {   
    
     /*
    
                                
    • 
                                
  • POJ 1035 Spell checker(哈希表)
                                    aijuans
暴力求解--哈希表
                                    
    /*
题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词
要求按照输入时候的排名输出

题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重
*/

#include <iostream>
//#define 
using namespace std;
const int HASH =
    
                                
    • 
                                
  • 通过原型实现javascript Array的去重、最大值和最小值
                                    ayaoxinchao
JavaScriptarrayprototype
                                    
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 
实现代码如下： 
  
<script type="text/javascript">
	Array.prototype.unique = function() {
		var a = {};
		var le
    
                                
    • 
                                
  • UIWebView实现https双向认证请求
                                    bewithme
UIWebViewhttpsObjective-C
                                    
      
        什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 
中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存)
                                    bijian1013
redis数据库NoSQL
                                    
    3.事务处理 
        Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
    
                                
    • 
                                
  • 各数据库分页sql备忘
                                    bingyingao
oraclesql分页
                                    
    ORACLE 
 
下面这个效率很低 
SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 
 
下面这个效率很高 
SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
    
                                
    • 
                                
  • 【Scala七】Scala核心一：函数
                                    bit1129
scala
                                    
    1. 如果函数体只有一行代码，则可以不用写{},比如 
def print(x: Int) = println(x) 
一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 
  
def printWithValue(x: Int) : String= println(x); "ABC" 
  
上面的代码报错，因为，printWithValue的方法
    
                                
    • 
                                
  • 了解GHC的factorial编译过程
                                    bookjovi
haskell
                                    
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 
关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-LinkedHashMap
                                    BrokenDreams
LinkedHashMap
                                    
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。 
      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory
                                    bylijinnan
abstract
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


package design.pattern;

/*
 * Abstract Factory Pattern
 * 抽象工厂模式的目的是：
 * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇”
 * 这些接口是相关或者相依赖的
    
                                
    • 
                                
  • 压暗面部高光
                                    cherishLC
PS
                                    
    方法一、压暗高光&重新着色 
当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 
下面讲一下我今天处理高光区域的心得： 
皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 
处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 
如果想简化步骤，可以只进行着色（参看下面的步骤1
    
                                
    • 
                                
  • Java VisualVM监控远程JVM
                                    crabdave
visualvm
                                    
    Java VisualVM监控远程JVM  
  
JDK1.6开始自带的VisualVM就是不错的监控工具. 
这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面 
  
通过JMX连接远程机器, 需要经过下面的配置: 
1. 修改远程机器JDK配置文件 (我这里远程机器是linux). 
   
    
                                
    • 
                                
  • Saiku去掉登录模块
                                    daizj
saiku登录olapBI
                                    
     
1、修改applicationContext-saiku-webapp.xml 
 
<security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  
<security:intercept-url pattern=&qu
    
                                
    • 
                                
  • 浅析 Flex中的Focus
                                    dsjt
htmlFlexFlash
                                    
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 
 焦点、设置焦点、获得焦点、键盘事件 
 
 
 一、无焦点的困扰——组件监听不到键盘事件 
原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
    
                                
    • 
                                
  • Yii全局函数使用
                                    dcj3sjt126com
yii
                                    
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 
我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
    
                                
    • 
                                
  • 设计模式之单例模式二（解决无序写入的问题）
                                    come_for_dream
单例模式volatile乱序执行双重检验锁
                                    
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
    
                                
    • 
                                
  • 程序员从初级到高级的蜕变
                                    gcq511120594
框架工作PHPandroidhtml5
                                    
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 
我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 
现在我们把淫浸代码时间超过3年的开发人员称为
    
                                
    • 
                                
  • Reverse Linked List
                                    hcx2013
list
                                    
    Reverse a singly linked list. 
  
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
p
    
                                
    • 
                                
  • Spring4.1新特性——数据库集成测试
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • C# Ajax上传图片同时生成微缩图(附Demo)
                                    liyonghui160com

                                    
      
  
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 
        2.C#位图处理  System.Drawing。 
        3.最新demo支持IE7,IE8,Fir
    
                                
    • 
                                
  • Java list三种遍历方法性能比较
                                    pda158
java
                                    
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： 
package com.hisense.tiger.list;
import java.util.ArrayList;
import java.util.Iterator;
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇
                                    shoothao
seo商业与市场IT资源免费资源
                                    
     
 A.网站模板+logo+服务器主机+发票生成 
 
 
  HTML5 UP:响应式的HTML5和CSS3网站模板。 
  Bootswatch:免费的Bootstrap主题。 
  Templated:收集了845个免费的CSS和HTML5网站模板。 
  Wordpress.org|Wordpress.com:可免费创建你的新网站。 
  Strikingly:关注领域中免费无限的移动优
    
                                
    • 
                                
  • localStorage、sessionStorage
                                    uule
localStorage
                                    
    W3School 例子 
  
HTML5 提供了两种在客户端存储数据的新方法： 
localStorage - 没有时间限制的数据存储 
sessionStorage - 针对一个 session 的数据存储 
  
之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
    
                                
    •