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基础图层与蒙版使用技巧心得