java 线程thread基础知识点总结
1.线程Thread是指程序的运行流程。多线程的机制可以同时运行多个程序块，使程序运行的效率更高，也解决了传统程序设计语言所无法解决的问题。
2.如果在类里面要激活线程，必须先做好下面两项准备：
1.此类必须是扩展自Thread类，使自己成为它的子类。
2.线程的处理程序必须编在run()方法内。
3.run()方法是定义在Thread类里面的一个方法，因此把线程的程序代码编写在run()方法里，所做的就是对Thread.run()方法的复写。
4.Runnable接口里声明了抽象的run()方法，因此必须在实现了Runnable接口的类里明确定义run()方法(必须实现run()方法)。
5.每一个线程，在其创建和消亡之前，均会处于下列五种状态之一：创建、就绪、运行、阻塞、终止。
6.暂停状态的线程可由下列的情况所产生：
1.该线程调用对象的wait()方法时；
2.该线程本身调用sleep()方法时；
3.该线程和另一个线程join()在一起时。
7.被冻结因素消失的原因有：
1.如果线程是由调用对象的wait()方法所冻结，则该对象的notify()方法被调用时可解除冻结；
2.线程进入休眠sleep状态，但指定的休眠时间到了。
8.当线程的run()方法运行结束，或是由线程调用它的stop()方法时，由线程进入消亡状态。
9.Thread类里的sleep()方法可以用来控制线程的休眠状态，休眠的时间要视sleep()里的参数而定。
10.要强制某一线程运行，可以用join()方法。
11.join()方法会抛出InterruptedException的异常，所以编写时必须把join()方法编写在try-catch块内进行异常的捕获。
12.当多个线程对象操纵同一共享资源时，要使用synchronized关键字来进行资源的同步处理，可以是synchronized(this){要同步的代码块} 或者是声明方法时使用synchronized关键字
下面就做个例子：
一、标准例子
定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。
/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {
//定义了一个ThreadLocal变量，用来保存int或Integer数据
private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public Integer getNextNum() {
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get() 1);
return tl.get();
}
}
/**
* 测试线程
*
* @author leizhimin 2010-1-5 10:39:18
*/
public class TestThread extends Thread {
private MyThreadLocal tlt = new MyThreadLocal();
public TestThread(MyThreadLocal tlt) {
this.tlt = tlt;
}
@Override
public void run() {
for (int i = 0; i < 3; i ) {
System.out.println(Thread.currentThread().getName() "t" tlt.getNextNum());
}
}
}
/**
* ThreadLocal测试
*
* @author leizhimin 2010-1-5 10:43:48
*/
public class Test {
public static void main(String[] args) {
MyThreadLocal tlt = new MyThreadLocal();
Thread t1 = new TestThread(tlt);
Thread t2 = new TestThread(tlt);
Thread t3 = new TestThread(tlt);
Thread t4 = new TestThread(tlt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
可以看出，三个线程各自独立编号，互不影响：
hread-0 1
Thread-1 1
Thread-0 2
Thread-1 2
Thread-0 3
Thread-1 3
Thread-2 1
Thread-3 1
Thread-2 2
Thread-3 2
Thread-2 3
Thread-3 3
Process finished with exit code 0
tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。
二、不用ThreadLocal
假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：
/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {
private Integer t1 = 0;
public Integer getNextNum(){
return t1=t1 1;
}
// //定义了一个ThreadLocal变量，用来保存int或Integer数据
// private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
// @Override
// protected Integer initialValue() {
// return 0;
// }
// };
//
// public Integer getNextNum() {
// //将tl的值获取后加1，并更新设置t1的值
// tl.set(tl.get() 1);
// return tl.get();
// }
}
然后运行测试：
Thread-2 1
Thread-2 2
Thread-1 4
Thread-1 6
Thread-3 3
Thread-3 9
Thread-3 10
Thread-1 8
Thread-0 7
Thread-0 11
Thread-0 12
Thread-2 5
Process finished with exit code 0
从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。
三、自己实现个ThreadLocal
package com.lavasoft.test2;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {
//定义了一个ThreadLocal变量，用来保存int或Integer数据
private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public Integer getNextNum() {
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get() 1);
return tl.get();
}
}
class ThreadLocal<T> {
private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
public ThreadLocal() {
}
protected T initialValue() {
return null;
}
public T get() {
Thread t = Thread.currentThread();
T obj = map.get(t);
if (obj == null && !map.containsKey(t)) {
obj = initialValue();
map.put(t, obj);
}
return obj;
}
public void set(T value) {
map.put(Thread.currentThread(), value);
}
public void remove() {
map.remove(Thread.currentThread());
}
}
运行测试：
Thread-0 1
Thread-0 2
Thread-0 3
Thread-2 1
Thread-2 2
Thread-3 1
Thread-2 3
Thread-3 2
Thread-1 1
Thread-3 3
Thread-1 2
Thread-1 3
Process finished with exit code 0
很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。
多线程优点：
A、进程之间不能共享内存，但线程之间共享内存非常容易。
B、系统创建进程需要为该进程重新分配系统资源，但创建线程则代价要小得多，因此使用线程来实现多任务并发比多进程的效率高。
C、Java语言内置多线程功能支持，而不是单纯的作为底层操作系统的调度方式，从而简化Java的多线程编程
您可能感兴趣的文章：
java创建线程的方法汇总
java 线程thread基础知识点总结
超详细的Java多线程教程
Java并发控制机制学习笔记
java多线程的优先级实例程序
(原)JAVA入门书籍读后感
学习html5需要什么基础？小白能学会吗
go 协程
经典Java线程面试题70道
photoshop基础图层与蒙版使用技巧心得