<a target="_blank" href="http://www.javahelp.com.cn/">java帮帮-it资源分享网</a>
六、黑马程序员—线程技术
第六篇
1、进程和线程
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中
可以有多个线程。比如在 windows 系统中，一个运行的 xx.exe 就是一个进程。
java 程序的进程里有几个线程:主线程, 垃圾回收线程(后台线程)
线程是指进程中的一个执行任务(控制单元)，一个进程中可以运行多个线程,多个线程可共享
数据。
多进程:操作系统中同时运行的多个程序;
多线程:在同一个进程中同时运行的多个任务;
一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个控制单元。
并发运行。如：多线程下载软件。
可以完成同时运行，但是通过程序运行的结果发现，虽然同时运行，但是每一次结果都不一
致。
因为多线程存在一个特性：随机性。
造成的原因：cpu 在瞬间不断切换去处理各个线程而导致的。
可以理解成多个线程在抢 cpu 资源。
我的总结：
多线程下载:此时线程可以理解为下载的通道，一个线程就是一个文件的下载通道，多
线程也就是同时开起好几个下载通道.当服务器提供下载服务时，使用下载者是共享带宽的，
在优先级相同的情况下，总服务器会对总下载线程进行平均分配。不难理解，如果你线程
多的话，那下载的越快。现流行的下载软件都支持多线程。
多线程是为了同步完成多项任务,不是为了提供运行效率,通过提高资源使用效率来提
高系统的效率.
线程是在同一时间需要完成多项任务的时候实现的.
线程与进程的比较
线程具有许多传统进程所具有的特征，故又称为轻型进程(light—weight process)或进程
元；而把传统的进程称为重型进程(heavy—weight process)，它相当于只有一个线程的任务。
在引入了线程的操作系统中，通常一个进程都有若干个线程，至少需要一个线程。
进程与线程的区别：
1.进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。
2.线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可
以影响的。
2、创建线程方式
1、继承 thread 类
子类覆写父类中的 run 方法，将线程运行的代码存放在 run 中。
建立子类对象的同时线程也被创建。
通过调用 start 方法开启线程。
2、实现 runnable 接口
子类覆盖接口中的 run 方法。
通过 thread 类创建线程，并将实现了 runnable 接口的子类对象作为参数传递给 thread
类的构造函数。
thread 类对象调用 start 方法开启线程。
可使用匿名内部类来写
eg：
package july7;
//线程的两种方法
class mythread extends thread{
private string name;
public mythread(string name) {
super();
this.name = name;
}
public void run(){
system.out.println(name+"启动！");
class yourthread implements runnable{
public yourthread(string name) {
@override
public void run() {
for (int i = 0; i < 3; i++) {
system.out.println(thread.currentthread().getname()+" 第
"+i+"次启动！");
public class demo1 {
public static void main(string[] args) {
for (int i = 0; i < 100; i++) {
if(i == 50){
new mythread("刘昭").start();
new thread(new yourthread(""),"章泽天").start();
thread 类中 run()和 start()方法的区别如下：
run()方法:在本线程内调用该 runnable 对象的 run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该 runnable 对象的 run()方法，不能多次启动一个
线程；
3、两种进程创建方式比较
a extends thread：
简单
不能再继承其他类了(java 单继承)
同份资源不共享
a implements runnable:(推荐)
多个线程共享一个目标资源，适合多线程处理同一份资源。
该类还可以继承其他类，也可以实现其他接口。
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。
//线程卖票的例子
class sellticket extends thread{
private int num = 50;
public sellticket(string name) {
for (int i = 1; i <= num; i++) {
system.out.println(name+"卖出了第"+i+"张票！");
class mysell implements runnable{
system.out.println(thread.currentthread().getname()+" 卖
出了第"+i+"张票！");
public class demo2 {
public static void main(string[] args) throws exception {
new sellticket("a").start();
new sellticket("b").start();
new sellticket("c").start();
new thread(new mysell(),"d").start();
new thread(new mysell(),"e").start();
new thread(new mysell(),"f").start();
for (int i = 10; i > 0; i--) {
system.out.println(i);
thread.sleep(1000);
为什么要覆盖 run 方法呢？
thread 类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存
储功能就是 run 方法.
也就是说 thread 类中的 run 方法，用于存储线程要运行的代码。
4、线程的生命周期
thread 类内部有个 public 的枚举 thread.state，里边将线程的状态分为：
new-------新建状态，至今尚未启动的线程处于这种状态。
runnable-------运行状态，正在 java 虚拟机中执行的线程处于这种状态。
blocked-------阻塞状态，受阻塞并等待某个监视器锁的线程处于这种状态。
waiting-------冻结状态，无限期地等待另一个线程来执行某一特定操作的线程处于
这种状态。
timed_waiting-------等待状态，等待另一个线程来执行取决于指定等待时间的操作
的线程处于这种状态。
terminated-------已退出的线程处于这种状态。
如何停止线程？
只有一种，run 方法结束。 开启多线程运行，运行代码通常是循环结构。 只要控制
住循环，就可以让 run 方法结束，也就是线程结束。
5、控制线程
join 方法：调用 join 方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，
必须等到该线程结束后其他线程才可以运行。
有人也把这种方式成为联合线程
join 方法的重载方法:
join(long millis):
join(long millis,int nanos):
通常很少使用第三个方法:
程序无须精确到一纳秒;
计算机硬件和操作系统也无法精确到一纳秒;
class mythreaddemo implements runnable{
for (int i = 0; i < 50; i++) {
system.out.println(thread.currentthread().getname()+" 正
在运行！"+i);
if(i == 25){
try {
new thread(new mythreaddemo(),"刘昭").join();
} catch (interruptedexception e) {
e.printstacktrace();
public class demore10 {
new thread(new mythreaddemo(),"刘昭").start();
new thread(new mythreaddemo(),"章泽天").start();
daemon
后台线程：处于后台运行，任务是为其他线程提供服务。也称为“守护线程”或“精灵线程”。
jvm 的垃圾回收就是典型的后台线程。
特点：若所有的前台线程都死亡，后台线程自动死亡。
设置后台线程：thread 对象 setdaemon(true);
setdaemon(true)必须在 start()调用前。否则出现 illegalthreadstateexception 异常；
前台线程创建的线程默认是前台线程;
判断是否是后台线程：使用 thread 对象的 isdaemon()方法；
并且当且仅当创建线程是后台线程时，新线程才是后台线程。
sleep
线程休眠:
让执行的线程暂停一段时间，进入阻塞状态。
sleep(long milllis) throws interruptedexception：毫秒
sleep(long millis,int nanos)
throws interruptedexception:毫秒，纳秒
调用 sleep()后，在指定时间段之内，该线程不会获得执行的机会。
控制线程之优先级
每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。
并非线程优先级越高的就一定先执行，哪个线程的先运行取决于 cpu 的调度;
默认情况下 main 线程具有普通的优先级，而它创建的线程也具有普通优先级。
thread 对象的 setpriority(int x)和 getpriority()来设置和获得优先级。
max_priority : 值是 10
min_priority : 值是 1
norm_priority : 值是 5(主方法默认优先级)
yield
线程礼让:
暂停当前正在执行的线程对象，并执行其他线程；
thread 的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。所
以完全有可能：某个线程调用了 yield()之后，线程调度器又把他调度出来重新执行。
我的总结：用到时查询 api！
6、多线程安全问题
导致安全问题的出现的原因：
多个线程访问出现延迟。
线程随机性。
注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
我们可以通过 thread.sleep(long time)方法来简单模拟延迟情况。
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还
没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不
可以参与执行。
eg：在前面的卖票例子上，在每卖票的前面加上模拟延时的语句！
class selldemo implements runnable{
for (int i = 0; i < 200; i++) {
if(num > 0){
//因为它不可以直接调用getname()方法，所以必须要获取当前线
程。
thread.sleep(10);
system.out.println(thread.currentthread().getname()+" 卖 出 第
"+num--+"张票！");
public class demo3 {
selldemo s = new selldemo();
new thread(s,"a").start();
new thread(s,"b").start();
new thread(s,"c").start();
输出：这样的话，会出现买了第 0，甚至-1 张票的情况！
7、多线程安全问题的解决方法
三种方法：
同步代码块：
synchronized(obj)
{
//obj 表示同步监视器,是同一个同步对象
/**.....
todo something
*/
同步方法
格式：
在方法上加上 synchronized 修饰符即可。（一般不直接在 run 方法上加！）
synchronized 返回值类型 方法名(参数列表)
同步方法的同步监听器其实的是 this
静态方法的同步
同步代码块
static 不能和 this 连用
静态方法的默认同步锁是当前方法所在类的.class 对象
同步锁
jkd1.5 后的另一种同步机制：
通过显示定义同步锁对象来实现同步，这种机制，同步锁应该使用 lock 对象充当。
在实现线程安全控制中，通常使用 reentrantlock(可重入锁)。使用该对象可以显示地加锁和
解锁。
具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，
但功能更强大。
public class x {
private final reentrantlock lock = new reentrantlock();
//定义需要保证线程安全的方法
public void m(){
//加锁
lock.lock();
try{
//... method body
}finally{
//在 finally 释放锁
lock.unlock();
修改后的例子：
//同步代码块
synchronized (this) {
//同步方法
class finaldemo1 implements runnable {
gen();
public synchronized void gen() {
if (num > 0) {
system.out.println(thread.currentthread().getname() +
"卖出了第"
+ num-- + "张票！");
public class demo6 {
finaldemo1 f = new finaldemo1();
new thread(f, "a").start();
new thread(f, "b").start();
new thread(f, "c").start();
//线程同步锁
import java.util.concurrent.locks.reentrantlock;
//同步锁
class finaldemo2 implements runnable {
public void gen() {
//for (int i = 0; i < 100; i++) {
system.out.println(thread.currentthread().getname() + "卖出了第"
//}
public class demo7 {
finaldemo2 f = new finaldemo2();
8、线程通信
有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;
我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数
据空间取出数据(消费者);
因为线程的不确定性，存在于以下两种情况：
若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，cpu 就切换到了消费者线
程，消费者线程把姓名和上一个人的性别联系到一起；
生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者
放入新的数据，又重复的取出已取过的数据；
生产者和消费者
wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用 notify()或
notifyall()为止。
notify():唤醒在同一对象监听器中调用 wait 方法的第一个线程。
notifyall():唤醒在同一对象监听器中调用 wait 方法的所有线程。
这三个方法只能让同步监听器调用:
在同步方法中: 谁调用
在同步代码块中: 谁调用
wait()、notify()、notifyall()，这三个方法属于 object 不属于 thread，这三个方法必须由同
步监视对象来调用，两种情况：
1.synchronized 修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以
在同步方法中调用这三个方法;
2.synchronized 修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该
对象调用这三个方法;
可要是我们使用的是 lock 对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就
不能使用者三个方法了,那该咋办呢?
此时,lock 代替了同步方法或同步代码块,condition 代替了同步监视器的功能;
condition 对象通过 lock 对象的 newcondition()方法创建;
里面方法包括:
await(): 等价于同步监听器的 wait()方法;
signal(): 等价于同步监听器的 notify()方法;
signalall(): 等价于同步监听器的 notifyall()方法;
例子：设置属性
容易出现的问题是：
名字和性别不对应！
线程通信，很好！
class person{
private string sex;
private boolean isimpty = boolean.true;//内存区为空！
public string getname() {
return name;
public void setname(string name) {
public string getsex() {
return sex;
public void setsex(string sex) {
this.sex = sex;
public void set(string name,string sex){
while(!isimpty.equals(boolean.true)){//不为空的话等待消费者
消费！
this.wait();
this.name = name;//为空的话生产者创造！
isimpty = boolean.false;//创造结束后修改属性！
this.notifyall();
public void get(){
while(!isimpty.equals(boolean.false)){
system.out.println(" 姓 名 "+getname()+ ", "+" 性 别
"+getsex());
isimpty = boolean.true;
class producer implements runnable{
private person p;
public producer(person p) {
this.p = p;
if( i % 2 == 0){
p.set("刘昭", "男");
}else{
p.set("章泽天", "女");
class consumer implements runnable{
public consumer(person p) {
p.get();
public class demo9 {
person p = new person();
new thread(new producer(p)).start();
new thread(new consumer(p)).start();