黑马程序员_ 多线程解析

最新推荐文章于 2025-05-18 20:51:20 发布

原创最新推荐文章于 2025-05-18 20:51:20 发布 · 177 阅读

CC 4.0 BY-SA版权

---------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

多线程：

什么是进程？
进程：计算机中的正在执行的程序。
而每一个进程想要执行都需要至少有一个控制单元。
什么是线程？
进程中的控制单元就是线程。

开启了多线程有什么好处？
可以让多部分代码同时执行。
例如：聊天程序。收数据和发数据是同时运行的。

启动JVM，系统就会创建一个进程，该进程就会启动一个主线程，主线程要运行的代码在main方法中。
(其实还启动了一个线程，专门用于垃圾回收。)

----------------------
线程的创建方式：
1，继承Thread类。该Thread类用于线程这类事物的描述。只要通过继承Thread类，将代码存入run方法中即可。
步骤：
1，定义类extends Thread。
2，复写Thread类中的run方法。将多线程要执行的代码存放在run方法中。
3，创建Thread类的子类对象，创建线程。
4，调用start方法，开启线程，并执行run方法。
2，实现Runnable接口，对外提供规则，让自定义类具备功能扩展，因为java的单继承局限性。
1，实现Runnable接口。
2，复写Runnable接口中的run方法。
3，创建Thread类的对象，创建线程。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
传递的原因：是为了让多线程去执行自定义的run方法。
因为run方法所属的对象是Runnable接口的子类对象，所以将该对象在线程初始化的时候进行传递。
线程以初始化就明确了要执行的线程代码位置。

5，调用Thread类start方法，开启线程，并执行Runnable接口子类的run方法。

所以，如果自定义类已有明确的父类，那么它内部需要被多线程执行的代码，只能存入Runnable接口的run方法中。
class SubDemo extends Demo implements Runnable
{
public void run()
{
show();
}
void show()
{
//需要被多线程执行的代码
}
}

在创建多线程时，建议使用第二种方式.
原因：
1，该种方式避免了单继承的局限性。
2，可以实现多个线程的资源共享。

售票的例子。

--------------------------------------

多线程的安全问题：
售票时居然会发生打印负号票的情况。

造成安全问题的原因：
多条语句在对同一数据资源进行操作，而这些语句被多个线程分开执行时，容易出现数据资源错误。
而到值安全问题的产生。

解决思想：
那就是将这多条语句进行封装，一次只能让一个线程都执行完后，才让另一个线程执行该代码。

解决方式：
同步。

同步的原理：就是将代码进行封装，并加锁。

同步的前提：
1，要有两个或者两个异常的线程。
2，必须多个线程使用的是同一个锁。

同步的格式：
1，同步代码块。
synchronized(obj)
{
需要被同步的语句。
}
2，同步函数。
其实就是在函数上加上一个synchronized修饰符。

两个格式有什么区别？
同步代码块可以让任意对象作为锁存在。只要保证多个线程用的是同一个对象(锁)即可。
同步函数使用的锁是this。

注意：当同步函数被static修饰时，那么这时使用的锁就不是this了。因为静态函数不具备this引用。
使用的锁是该类对应的字节码文件对象。该对象的表现形式是：类名.class

单例设计模式的懒汉式。
class Single
{
private static Single s = null;

private Single(){}

public static Single getInstance()
{
if(s==null)
s = new Single();
return s;
}
}
当多线程并发访问getInstance()方法时，容易出现线程安全问题。不能保证对象的唯一性。

这时我们需要将其同步。那么将该函数用synchronized 关键字修饰是可以解决安全问题的。
但是效率很低。
这时可以采取一种优化的方式。双重判断的形式。

public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}

同步的好处：
解决了多线程的安全问题。

同步的弊端：
1，相对消耗资源。
2，容易出现死锁。(当这个同步嵌套的时候容易出现，大家在开发时，尽量避免。)

//定义锁类。
class MyLock
{
static MyLock locka = new MyLock();
static MyLock lockb = new MyLock();
}

class Demo implements Runnable
{
private boolean flag ;
Demo(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println("if......locka");
synchronized(MyLock.lockb)
{
System.out.println("if......lockb");

}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println("else......lockb");
synchronized(MyLock.locka)
{
System.out.println("else......locka");

}
}
}
}
}
}

class DeadLockDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo(true);
Demo d2 = new Demo(false);

new Thread(d1).start();
new Thread(d2).start();
}
}

-----------------------------------

线程间通信。
多个线程在处理同一个数据资源，但是处理的动作却不一致。
这里就用到一个机制等待/唤醒机制。

等待和唤醒：
wait():让线程处于等待状态。这时线程会释放锁。并存入到了线程池中。
notify()：通常唤醒线程池中的第一个。
notifyAll()：将线程池中的所有等待线程都唤醒。

这三个方法都需要定义在同步当中。因为要标识出它们所作用的锁。
如果用在同步外，有可能发生无效线程状态异常。
三个方法为什么定义在Object类中？因为锁可以任意对象，被任意对象都能调用的方法肯定定义在Object类。

//需求：两个线程对同一个资源进行操作，一个赋值姓名和性别，一个线程负责打印姓名和性别。
//1,定义资源。
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(InterruptedException e){}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}

public synchronized void out()
{
if(!flag)
try{this.wait();}catch(InterruptedException e){}
System.out.println(name+"..."+sex);
flag = false;
this.notify();
}
}

class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
if(x==0)
{
r.set("mike","nan");
}
else
r.set("丽丽","女女");
x = (x+1)%2;
}
}
}

class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}

class ResDemo
{
public static void main(String[] args)
{
Res r = new Res();

new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}

wait()和sleep()的特点：
wait：可以有时间限定，也可以没有时间限定。
sleep：必须有时间限定。

wait：释放cpu执行资源，也释放锁。
sleep：释放cpu执行资源，不释放锁。
----------------------------------------

线程间通信的演化。
需求：
当多个线程进行通信时，一部分线程在进行存储动作，一部分线程在进行取出动作。
无论多少个线程进行存储，只有可以可以执行，无论多少个线程进行取出，只能取出一次。

class Res
{
private String name;
private boolean flag;
private int count = 0;

public synchronized void set(String name)throws InterruptedException
{
while(flag)
wait();
this.name = name;
add();
System.out.println(Thread.currentThread().getName()+"----生产----"+name+"::"+count);
flag = true;
notifyAll();

}
public synchronized void out()throws InterruptedException
{
while(!flag)
wait();
System.out.println(Thread.currentThread().getName()+"....消费...."+name+"::"+count);
flag = false;
notifyAll();
}
public void add()
{
count++;
}
}

class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
try{r.set("商品");}catch(InterruptedException e){}
}
}
}
class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
try{r.out();}catch(InterruptedException e){}
}
}
}

class ResDemo
{
public static void main(String[] args)
{
Res r = new Res();

//创建两个生成者
new Thread(new Input(r)).start();
new Thread(new Input(r)).start();
//创建两个消费者
new Thread(new Output(r)).start();
new Thread(new Output(r)).start();
}
}

发现要么就生产不断的生产，却没有被消费，要么就是消费者不断的消费，却没有生产。
发生的原因的是：当线程等待时。再次被唤醒，不会在去判断标记flag。
那么就会发生数据错乱的情况。

解决办法：一定要醒来的线程再一次判断标记。所以要将判断的标记的if改成while。
这时就将if(flag)改成while(flag).

改完之后发现程序虽然没有结束，但是生产者消费者都不再运行，
因为都处于wait状态。

原因：是出现循环判断后，线程每一次都判断标记，都会出现等待的情况，
例如：3个线程等待，第四个线程，唤醒了其中一个，而这一个也是和该线程属于同一方的。

解决：希望可以唤醒另一放的线程。比如：消费需要去唤醒生产的。
而在Object提供的监视器方法中只提供了notify，和notifyAll进行唤醒。
所以这时可以使用notifyAll，将所有等待的线程都唤醒，这些线程中就包括对方线程。

就需要将代码中的notify改成notifyAll。

结果：程序正常运行。

但是，我们还是希望只唤醒对方。因为唤醒本方没意义，而且消耗资源。
在java.util.concurrent.locks包中，提供了一些对象。
Lock接口：替代了synchronized同步，将隐式获取锁，释放锁，变成了显示的获取和释放锁。可以由用户来执行。
常见方法：
lock():获取锁。
unlock():释放锁。
注意使用：在查阅api文档时，发现了一个使用技巧：try{需要同步的代码} finally{释放锁}
newCondition():获取监视器对象。
|--ReentrantLock:接口子类。
Condition接口：替代了Object中的监视器的方法。wait notify notifyAll.
如何获取指定锁的监视器对象呢？可以通过Lock接口的newCondition()方法获取。
await():线程等待。会抛出异常。
signal():唤醒线程。
接下来，就使用新的对象和方法将源程序改写。
这时就能完成一方唤醒的肯定是另一方。
class Res
{
private String name;
private boolean flag;
private int count = 0;
private Lock lock = new ReentrantLock();
private Condition setCon = lock.newCondition();
private Condition outCon = lock.newCondition();

public void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
setCon.await();
this.name = name;
add();
System.out.println(Thread.currentThread().getName()+"----生产----"+name+"::"+count);
flag = true;
outCon.signal();
}
finally
{
lock.unlock();
}

}
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
outCon.await();
System.out.println(Thread.currentThread().getName()+"....消费...."+name+"::"+count);
flag = false;
setCon.signal();
}
finally
{
lock.unlock();
}

}
public void add()
{
count++;
}
}

class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
try{r.set("商品");}catch(InterruptedException e){}
}
}
}
class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
try{r.out();}catch(InterruptedException e){}
}
}
}

class ResDemo
{
public static void main(String[] args)
{
Res r = new Res();

//创建两个生成者
new Thread(new Input(r)).start();
new Thread(new Input(r)).start();
//创建两个消费者
new Thread(new Output(r)).start();
new Thread(new Output(r)).start();
}
}

-----------------------------------

如何停止线程呢？
让线程运行的run方法结束。
只要线程运行的代码结束了。线程会自动结束。

通常线程代码中都会写循环。只要控制住循环即可。
那么可以通过定义循环标记的形式来完成。

在满足某些条件时，就让改变标记，线程在执行到标记时，循环就会停止。线程就会结束。

但是有一种情况，当线程处于了冻结状态时，比如执行到了wait方法，那么这时线程是不会执行标记的。

如果还没有唤醒机制，那么程序不会结束。

这时，只能强制让线程恢复到运行状态中来，让其执行标记，并结束。

那么可以使用Thread类中的interrupt()方法。
该方法用于中断线程的冻结状态。强制让线程恢复到运行状态中来，
但是这种强制会发生InterruptedException。所以要进行一下处理。

class Demo implements Runnable
{
private boolean flag = true;
public synchronized void run()
{
while(flag)
{
try
{
wait();
}
catch(InterruptedException e)
{
flag = false;
}
}
}
}

main()
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.interrupt();
}

参考：day12\StopThreadDemo.java

---------------------------------------

其他方法：
setDaemon(boolean b):如果参数为true，那么会将该线程标记为后台线程。

该方法要用在开启线程前。
后台线程的特点：开启后，和前台线程一样会互相抢CPU的执行资源。
只有在结束的时候，有自身，当所有的前台线程都结束了，后台线程会自动结束。
join():线程加入。等待该线程结束。
比如主线程执行了到了A线程的join方法。这时主线程会释放cpu的执行资源，让其他线程执行。
其他线程中包含A线程。那么主线程什么执行呢？主线程只等A线程结束后，就会恢复到运行状态。
如果这时还有其他线程在执行，那么主线会和其他线程共同抢资源运行。

通常可以临时让一个线程加入，并执行完。

setPriority(int):设置线程的优先级。优先级1~10，为了方便应用，给较为明显的数值进行名称的定义。
Thread类中的三个常量：MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY
线程开启时，默认优先级都是5.

yield():暂停线程，当前线程释放资源，可以让其他线程得以执行。
它的出现可以暂缓程序的执行。

-----------------------

在程序中的应用：
可以随时的通过匿名内部类开一个控制单元。

class Demo
{
main()
{
new Thread()//创建的是Thread的子类匿名对象。(传说中的匿名内部类)
{
public void run()
{
code...;
}
}.start();

code...;//主线程代码。

Runnable r = new Runnable()
{
public void run()
{
code...;
}
};

new Thread(r).start();
}
}