黑马程序员---------笔记整理（java基础八-----多线程）

---------------------- android培训、java培训、期待与您交流！ ----------------------

今天有点晕晕的，说不清的感觉，总觉得时间有点紧，不大够用。不知道究竟是怎么了。慢慢来吧，饭总得一口口吃。尽力！！！来吧，让暴风雨来得更猛烈些吧。

1.1 线程的优势

1.2线程的弊端

1.3 线程和进程的区别

1.4多线程的目的

1.5计算机执行任务的原理

1.6 创建线程的两种方式

1.7 线程的安全问题产生的原因

1.9 线程状态图解

2.0 锁

2.1 死锁

2.2 延迟加载同步代码块儿

2.3 线程间通讯

2.4 同步

2.5 其他

多线程

进程：正在运行中的程序。

线程：就是进程中一个负责程序执行的控制单元（执行路径）

1.1 线程的优势

多线程好处：解决了多部分同时运行的问题

1.2线程的弊端

多线程的弊端：线程太多回到效率的降低，因为线程的执行依靠的是CPU的来回切换。 1.3 线程和进程的区别

一个进程中可以多执行路径，称为多线程。

一个进程中至少要有一个线程。
了解：

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者《操作系统的设计与实现》。对就个问题说得比较清楚。

1.4多线程的目的

开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的
内容，这个内容称为线程要执行的任务

1.5计算机执行任务的原理

应用程序的执行都是cpu在做着快速的切换完成的，而且切换是随机的 1.6 创建线程的两种方式

1.继承Thread。

继承Thread类；

覆盖Thread类中的run方法；

直接创建Threadde子类对象创建线程；

调用start方法开启线程并调用线程的任务run方法。

另外可以通过Thread的getName()获取线程的名称。

主要代码：

class ThreadDemo extends Thread

{

public void run()

{

for (int i=0;i<10;i++)

{

System.out.println("线程"+getName()+"正在运行:"+i);

}

}

}

class Demo

{

public static void main(String args[])

{

ThreadDemo a=new ThreadDemo();

ThreadDemo b=new ThreadDemo();

a.start();

b.start();

}

}

2.实现runnable接口

定义类实现Runnable接口；

覆盖接口的run的方法，将线程的任务代码封装到run方法中；

通过Thread类创建线程对象，将Runnabl接口的子类对象作为Thread类的构造函数的参数进行传递

（原因：线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务）。

调用线程对象的start方法开启线程。

主要代码：

class RunnableDemo implements Runnable //实现Runnable

{

public void run()

{

show();

}

private void show()

{

for (int i=1;i<10 ;i++ )

{

System.out.println(Thread.currentThread().getName()+" "+i);

}

}

}

class Demo

{

public static void main(String[] args)

{

RunnableDemo a=new RunnableDemo();

Thread b=new Thread(a); //将任务封装成对象，将其传入线程中

Thread b1=new Thread(a);

b.start();

b1.start();

}
}

总结：两种方法的比较：实现Runnable接口，将线程的任务从线程的子类中分离出来的，进行了单独的封装，按照面向对象的思想将任务的封装成对象，避免了java中单继承的局限性。（创建线程第二种方式较好）

1.7 线程的安全问题产生的原因

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

解决思路：就是将多条操作共享的线程代码封装起来，当有线程在执行这些代码的时候，其他线程就不可以参与运算，执行完以后，

其他的线程才 可以执行。

java中的体现：

（同步代码块，解决线程的安全问题，但是降低了效率。因为同步外的线程 都会判断同步锁，同步的前提：同步中必须有有多

个线程并使用用一个锁。）

synchronized(对象)

｛

需要被同步的代码；

｝

主要代码：

class Test implements Runnable

{

private int num=50;

public void run()

{

while(num>0)//线程每循环一次，释放cpu的执行权，进来再次判断。

{

synchronized(this)//一次只能有一个线程进来售票

{

if(num>0)

System.out.println(Thread.currentThread().getName()+"正在出售："+num--);

}

}

}

}

class TestDemo

{

public static void main(String[] args)

{

Test a=new Test();

Thread t1=new Thread(a);

Thread t2=new Thread(a);

t1.start();

t2.start();

}

}

2.4 同步

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

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁

同步的前提：同步中必须有多个线程并使用同一个锁。

同步的表现：多个线程运行到同步时，谁具备执行权，其他线程就不参与共享数据的操作。

同步代码块儿和同步函数区别：
同步函数的锁是固定的this。

同步代码块的锁是任意的对象。

建议使用同步代码块。

静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前 类名.class表示。
1.9 线程状态图解



分析：

状态一,创建，使用start（）开启线程。

状态二,运行（具备着执行资格，具备着执行权）

状态三，冻结（释放执行权，同时释放执行资格）

从运行到冻结的方式：

sleep(time),sleep(time)时间到，进入临时阻塞状态（具备着执行资格,但是不具备执行权,正在等待执行权）

wait（）线程等待，notify（）线程唤醒，进入临时阻塞状态。

状态四，消亡

从运行到消亡的方式：

stop（)中止线程；

run（）方法结束，线程的任务结束。

2.0 锁

锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制

2.1 死锁

同步代码块之间的嵌套。就是有两把锁，你那我需要的那把，我持有你需要的那把，而我们谁也不释放该锁，这样

我们都不能进去，在那等待。

主要代码:

class DeadLock implements Runnable

{

public boolean flag=false;

public void run()

{

if (!flag)

{ while(true)

{

synchronized(this)

{

synchronized(DeadLock.class)

{

System.out.println("true");

}

}

}

}

else

{

while(true)

{

synchronized(DeadLock.class)

{

synchronized(this)

{

System.out.println("false");

}

}

}

}

}

}

class Test

{

public static void main(String[] args)

{

DeadLock a=new DeadLock ();

Thread t1=new Thread(a);

Thread t2=new Thread(a);

t1.start();

try{ Thread.sleep(10);}catch(Exception e){}

a.flag=true;

t2.start();

}

}

2.2 延迟加载同步代码块儿

/*单例设计模式：

//饿汉式。

/*

class Single

{

private
static final Single s = new Single();
private
Single(){}
public
static Single getInstance()
{

return
s;

}

}

//懒汉式，请给我写个延迟加载的单例设计模式。

/*

区别：

懒汉式特点是实例的延迟加载。多线程访问时回出现安全问题。

可以加同步来解决。可以用同步代码块或者同步函数。有些低效，

用双重判断可以效率问题。同步的时候，用的锁是，该类所属的字节码文件对象。

*/

class Single

{

private static Single s = null;

private Single(){}

public static Single getInstance()

{

if(s==null)

{

synchronized(Single.class)

{

if (s==null)

{

s = new Single();

}

}

}

return s;

}

}

class SingleDmeo

{

public static void main(String[] args)

{

System.out.println("Hello World!");

}

}

2.3 线程间通讯

多线程在处理同一资源，但是任务却不同。

1.1 等待唤醒机制：

涉及的方法：

1， wait(); 是为了让线程处于冻结状态，释放CPU执行权和执行资格，被wait的线程会被存储到线程池中。

2， notify(); 是用于唤醒线程池中的一个线程(任意的线程)。

3， notifyAll(); 是用于唤醒线程池中的所有线程。

这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。必须要明确到底操作的是哪个锁上的线程。

为什么需要唤醒机制：

有时候我们多个线程在操作同一数据时，需要有一个先后顺序，当其中一个线程在操作该数据时，其他线程不能操作该数据，

这时候可能就会涉及到冻结和唤醒机制。

1.2 为什么操作线程的方法wait
notify notifyAll 定义在Object类中？

因为这些方法是监视器的方法，监视器其实就是锁，锁可以是任意的对象，任意的对象调用的方法一定定义在Object类当中。

1 .3 线程间通讯最重要的机制：

等待唤醒机制。

wait():让当前线程处于冻结状态，当前线程就被存储到了线程池中。

notify():唤醒线程池中的任意一个线程。让该线程恢复到运行状态，会具备cpu的执行资格。

notifyAll(): 唤醒线程池中的所有等待的线程，具备cpu的执行资格。

1.4 等待唤醒机制中，最常见的体现就是生产者消费者问题：



发现两个问题：

1，出现了错误的数据。是因为多生产和多消费的时候，被唤醒的线程没有再次判断标记就执行了。

解决是将if判断变成while判断。

2，发现有了while判断后，死锁了。

因为本方线程唤醒的有可能还是本方线程。所以导致了死锁。

解决：本方必须唤醒对方才有效。notify只能唤醒一个，还不确定。所以干脆唤醒全部，肯定包含对方，

至于被唤醒的本方，会判断标记是否继续等待。

示例代码：

class ThreadDemo4

{

public static void main(String [] args)

{

Resource r = new Resource();

Shengchan s = new Shengchan(r);

Xiaofei x = new Xiaofei(r);

Thread t1 = new Thread(s);

Thread t2 = new Thread(s);

Thread t3 = new Thread(x);

Thread t4 = new Thread(x);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

class Resource

{

private String name;

private int count = 1;

private boolean flag = false;

public synchronized void set(String name)

{

if(flag)

try{this.wait();}catch(InterruptedException e){}

this.name = name+count;

count++;

System.out.println(Thread.currentThread().getName()+"...生产者...."+this.name);

flag = true;

notify();

}

public synchronized void out()

{

if(!flag)

try{this.wait();}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+".........消费者........."+this.name);

flag = false;

notify();

}

}

class Shengchan implements Runnable

{

Resource r;

Shengchan(Resource r)

{

this.r = r;

}

public void run()

{

while(true)

r.set("烤鸭");

}

}

class Xiaofei implements Runnable

{

Resource r;

Xiaofei(Resource r)

{

this.r = r;

}

public void run()

{

while(true)

r.out();

}

}

编译后：



造成了线程的不安全的问题。

notify唤醒的是不确定的一其中的一个线程，造成了生产出的烤鸭没有被消费。

解决多生产多消费的线程安全问题：

示例代码：

class ThreadDemo4

{

public static void main(String [] args)

{

Resource r = new Resource();

Shengchan s = new Shengchan(r);

Xiaofei x = new Xiaofei(r);

Thread t1 = new Thread(s);

Thread t2 = new Thread(s);

Thread t3 = new Thread(x);

Thread t4 = new Thread(x);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

class Resource

{

private String name;

private int count = 1;

private boolean flag = false;

public synchronized void set(String name)

{

while(flag) //这里写while循环是为了当线程每次醒后再判断一次标记。

try{this.wait();}catch(InterruptedException e){}

this.name = name+count;

count++;

System.out.println(Thread.currentThread().getName()+"...生产者...."+this.name);

flag = true;

notifyAll();

}

public synchronized void out()

{

while(!flag)

try{this.wait();}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+".........消费者........."+this.name);

flag = false;

notifyAll();

}

}

class Shengchan implements Runnable

{

Resource r;

Shengchan(Resource r)

{

this.r = r;

}

public void run()

{

while(true)

r.set("烤鸭");

}

}

class Xiaofei implements Runnable

{

Resource r;

Xiaofei(Resource r)

{

this.r = r;

}

public void run()

{

while(true)

r.out();

}

}

1.5 同步代码块儿

同步代码块，对于锁的操作是隐式的

JDK1.5以后将同步和锁封装成了对象。并将操作锁的隐式方式定义到了对象中，将隐式动作编程了显示动作。



1.6 Lock接口

出现替代了同步代码块或者同步函数。将同步的隐式锁操作编程了显示锁操作。 同事更为灵活。可以一个锁上加上多组监视器。

lock(); 获取锁。

unlock();释放锁，通常需要定义finally代码块中。

JDK1.5版本后，对多线程中的内部细节进行了升级改良。

在java.util.concurrent.locks包中提供了一个Lock接口。

Lock接口中提供了 lock()获取锁 unlock释放锁的操作。

Lock接口更符合面向对象的思想，将锁这种事物封装成了对象。

public void run()

{

synchronized(obj)

{//获取锁。

code...

//释放锁。

}

}

但是对于释放和获取锁的操作，都是隐式的。

JDK1.5后，就有了新的方法，将锁封装成了对象。因为释放锁和获取锁动作，锁自己最清楚。

锁对象的类型就是Lock接口。

并提供了，显示的对锁的获取和释放的操作方法。

Lock lock;

public void run()

{

try

{

lock.lock();//获取锁。

code...throw ...

}

finally

{

lock.unlock();//释放锁.

}

}

Lock接口替代了synchronized .

Condition替代了Object类中监视器方法 wait
notify notifyAll。、

将监视器方法单独封装成了Condition对象。而且一个锁上可以组合多组监视器对象。

实现了多生产者多消费者时，本方只唤醒对方中一个的操作，提高效率。

1.7Condition接口

出现替代了Object中的wait
notify notifyAll方法。

await()，signal(); signalAll();

将这些监视器方法单独进行封装，变成了Condition监视器对象。

可以任意锁进行组合。

await(); 睡眠

signal();signalAll(); 唤醒

使用为一般是生产者是被消费者唤醒，消费者是被生产者唤醒。

1.8 停止线程：

1，stop方法

2，run方法结束。

stop方法已经过时。 所以只剩下一种办法：线程执行的代码结束，线程会自动终止。

1，run方法中通常都有循环语句，所以只要让循环结束即可，所以只要控制住循环的条件，最简单的方式就是定义标记。

怎么控制线程的任务结束呢？

任务中都会有循环结构，只要控制住循环就可以结束任务。

控制循环通常就用定义标记来完成。

但是如果线程处于了冻结状态，无法读取标记，如何结束呢？

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。但是强制动作会发

terruptedException,记得要处理。

示例代码：

class StopThread implements Runnable

{

private boolean flag = true;

public synchronized void run(){

while(flag){

try {

wait();//t0 t1

}catch (InterruptedException
e){

System.out.println(Thread.currentThread().getName()+"....."+e);

flag = false;

}

System.out.println(Thread.currentThread().getName()+"......++++");

}

}

public void setFlag(){

flag = false;

}

}

class StopThreadDemo

{

public static void main(String[] args) {

StopThread st = new StopThread();

Thread t1 = new Thread(st);

Thread t2 = new Thread(st);

t1.start();

t2.setDaemon(true);

t2.start();

int num = 1;

for(;;){

if(++num==50){

//st.setFlag();

t1.interrupt();

//t2.interrupt();

break;

}

System.out.println("main...."+num);

}

System.out.println("over");

}

}

临时加入一个线程运算时可以使用join方法。

面试题

class Test implements Runnable

{

public void run(Thread t)

{}

}

//如果错误 错误发生在哪一行？错误在第一行，应该被abstract修饰

class ThreadTest

{

public static void main(String[] args)

{

new Thread(new Runnable(){

public void run(){

System.out.println("runnable run");

}}){

public void run(){

System.out.println("subThread run");
}

}.start();

打印的是subThread run 运行以子类的为主，如果子类里面没有这个run()方法的话，就以任务线程的run为主，如果都没有的话，以父类自己的为主。

总结：

wait和sleep的区别:

wait可以指定时间也可以不指定.

sleep必须指定时间。

在同步中时，对于CPU的执行权和锁的处理不同。

wait：释放执行权，释放锁。

sleep：释放执行权，不释放锁。

wait方法，必须定义在同步中，sleep不一定。

-

--------------------- android培训、java培训、期待与您交流！ ----------------------