黑马程序员-----程序员之路_____多线程

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

一 多线程概述

1、进程和线程：

进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：进程内部的一条执行路径或者一个控制单元。

两者的区别：一个进程至少有一个线程，进程在执行过程中拥有独立的内存单元，而多个线程共享内存。

2、jvm多线程的启动是多线程吗？

java的虚拟机jvm启动的是单线程，就有发生内存泄露的可能，而我们使用java程序没出现这样的问题，也就是jvm启动至少有两个线程，一个执行java程序，一个执行垃圾回收。所以是多线程。而执行java程序的那个线程为主线程，存在于mian方法中。

3、多线程的优势：

解决了多部分同时运行的问题，提高效率

4、线程的弊端：

线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。

5、什么叫多线程以及多线程的特点：

一个进程中有多个线程，称为多线程。多线程的特点：随机性

6、实现多线程的方法：

实现多线程可以通过继承Thread类和实现Runnable接口。

在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现

(1)继承Thread

定义一个类继承Thread类

复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中

直接创建Thread的子类对象，创建线程

调用start()方法，开启线程(调用线程的任务run方法)

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

(2)实现Runnable接口；

定义一个类，实现Runnable接口；

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

创建Runnable接口的子类对象

将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象（原因：线程的任务

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

调用start()方法，启动线程。

两种方法区别：

(1)实现Runnable接口避免了单继承的局限性

(2)继承Thread类线程代码存放在Thread子类的run方法中

实现Runnable接口线程代码存放在接口的子类的run方法中；

package day11;
/*
需求：简单的卖票程序
多个窗口同时买票。
创建线程的第二种方式：实现Runnable接口
步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法
将线程要运行的代码存放在该run方法中
3，通过Thread类建立线程对象
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数
因为，自定义的run方法所属的对象时Runnable接口的子类对象，
所以要让先去指定指定对象的run方法，就必须明确该run方法所属对象。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢？
实现方式好处：避免了单继承的局限性
在定义线程时，建议使用实现方式
两种方式的区别：
继承Thread：线程代码存放Thread子类run方法中
实现Runnable，线程代码存在接口的子类的run方法中

*/
class Ticket implements Runnable //extends Thread
{
private int tick=100;
public void run()
{
while(true)
{
if(tick>0)
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
public class TicketDemo {
public static void main(String[] args) {
Ticket t=new Ticket();
Thread t1=new Thread(t);//创建了一个线程；
Thread t2=new Thread(t);//创建了一个线程；
Thread t3=new Thread(t);//创建了一个线程；
Thread t4=new Thread(t);//创建了一个线程；
t1.start();
t2.start();
t3.start();
t4.start();
/*
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
*/
}
}

7、创建线程是为什么要复写run方法？

Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

练习：

创建两个线程，和主线程交替运行，原来线程都有自己的默认的名称，Thread -编号 ，该编号从0开始，currentThread():获取当前线程对象，getName()：获取线程名称。设置线程名称：setName或者构造函数。

class Test extends Thread
{
//private String name;
Test(String name)
{
super(name);
//this.name=name;
}
public void  run()
{
for(int x=0;x<60;x++)
{
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run........."+x);
}
}
}
class ThreadTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
Test t1=new Test("one");
Test t2=new Test("two");
t1.start();
t2.start();
for(int x=0;x<50;x++)
{
System.out.println("main......"+x);
}
}

}

8、start()和run()方法有什么区别？

调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；

Start()方法:

start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。

Run()方法:

run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。

9、线程的几种状态：

新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个

时候，只是对象线程对象开辟了内存空间和初始化数据。

就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。在这个状态的线程对象，具有执行

资格，没有执行权。

运行：当线程对象获取到了CPU的资源。在这个状态的线程对象，既有执行资格，也有执行权。

冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。当然，他们可以回到运行

状态。只不过，不是直接回到。而是先回到就绪状态。

死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。



10、sleep()和wait()的区别：

(1)这两个方法来自不同的类，sleep()来自Thread类，而wait()来自Object类。

(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，

要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法

(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；

(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用

二 多线程的安全

package day11;
/*
通过分析，发现，打印0，-1，-2等错票
多线程的运行出现了安全问题
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。
另一个线程参与进来执行，导致共享数据的错误
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行
java对于多线程的安全问题提供了专业的解决方式
就是同步代码块
synchronized(对象)
{
需要被同步的代码
}
对象如同锁，持有锁的线程可以在同步中执行
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁
同步的提前：
1，必须要有两个或者两个以上的线程
2必须是多个线程使用同一个锁
必须保证同步中只能有一个线程在运行
好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，比较消耗资源

*/
class Ticket_1 implements Runnable
{
private int tick=100;
Object obj=new Object();
public void run()
{
while(true)
{
synchronized(obj)//同步代码块
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
}
}
public class TicketDemo1 {

public static void main(String[] args) {
// TODO Auto-generated method stub

Ticket_1 t=new Ticket_1();

Thread t1=new Thread(t);//创建了一个线程；
Thread t2=new Thread(t);//创建了一个线程；
Thread t3=new Thread(t);//创建了一个线程；
Thread t4=new Thread(t);//创建了一个线程；
t1.start();
t2.start();
t3.start();
t4.start();

}

}

1、多线程安全问题：

(1)原因：当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致

一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，

此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。

(2)解决方法：对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来

2、Java中多线程同步是什么？

同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一

个线程在修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出

现错误的结果。

3、什么是锁?锁的作用是什么?

锁就是对象

锁的作用是保证线程同步，解决线程安全问题。

持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。

同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，必须保证同步代码快的锁的对象和，否则会报错。同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是同一个对象，也就是都是this锁代表的对象。

静态同步函数的锁是class对象，如果同步函数被静态修饰后，使用的琐是该方法所在类的字节码

文件对象，类名.class

package day11;
/*
如果同步函数被静态修饰后，使用的锁死什么呢？

通过验证，发现不在是this ，因为静态方法中不可以定义this
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象
类名。class  该对象的类型是class

静态的同步方法使用的锁是该方法所在类的字节码文件对象。类名。class
*/
class Ticket_4 implements Runnable
{
private static int tick=100;
//Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
if(tick>0)
{
synchronized (Ticket_4.class)//同步代码块
{
try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"code:"+tick--);
}
}
}
}
else
while(true)
show();

}
public static synchronized void show()//同步函数//this
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"show:"+tick--);
}
}
}

class StaticMethodDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

Ticket_4 t=new Ticket_4();

Thread t1=new Thread(t);//创建了一个线程；
Thread t2=new Thread(t);//创建了一个线程；

t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag=false;
t2.start();

//Thread t3=new Thread(t);//创建了一个线程；
//Thread t4=new Thread(t);//创建了一个线程；
//t3.start();
//t4.start();

}

}

package day11;
/*
同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象的引用，就是this
所以同步函数使用的锁是this 。
通过改程序进行验证。
使用两个线程来卖票
一个线程在同步代码块中
一个线程在同步函数中
都在执行卖票动作
*/
class Ticket_3 implements Runnable
{
private int tick=300;
Object obj=new Object();
boolean flag=true;
public void run()
{
if(flag)
{
while(true)
{
if(tick>0)
{
synchronized (this)//同步代码块
{
try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"code:"+tick--);
}
}
}
}
else
while(true)
show();
}
public synchronized void show()//同步函数//this
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"show:"+tick--);
}
}
}
class ThisLockDemo {
public static void main(String[] args) {
Ticket_3 t=new Ticket_3();
Thread t1=new Thread(t);//创建了一个线程；
Thread t2=new Thread(t);//创建了一个线程；

t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag=false;
t2.start();
//Thread t3=new Thread(t);//创建了一个线程；
//Thread t4=new Thread(t);//创建了一个线程；
//t3.start();
//t4.start();
}
}

4、同步的前提:

(1)必须保证有两个以上线程

(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据

(3)必须保证同步中只有一个线程在运行

5、同步的好处和弊端

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

弊端：多线程都需要判断锁，比较消耗资源

6、同步的两种表现形式

(1)同步代码块:

可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象

考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。

格式：

synchronized(对象)

{

需同步的代码;

}

(2)同步函数

同步方法是指进入该方法时需要获取this对象的同步锁，在方法上使用synchronized关键字，

使用this对象作为锁，也就是使用了当前对象，因为锁住了方法，所以相对于代码块来说效率相对较低。

格式：

修饰词 synchronized 返回值类型 函数名(参数列表)

{

需同步的代码;

}

在jdk1.5后，用lock锁取代了synchronized，个人理解也就是对同步代码块做了修改，

并没有提供对同步方法的修改，主要还是效率问题吧。

7、多线程的单例设计模式：保证某个类中内存中只有一个对象

(1)饿汉式:

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

(2)懒汉式：

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;
}
}

饿汉式和懒汉式的区别：

饿汉式是类一加载进内存就创建好了对象；

懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。

懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题

可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

所以可以加双重判断来提高程序效率。

如将上述懒汉式的Instance函数改成同步：
8、死锁

两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

三 多线程之间的通信

1、多线程间通信概述

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同。

（1）为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个完成后需要唤醒负责消费的线程,同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

（2）怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止，使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程，多线程间通信用sleep很难实现，睡眠时间很难把握。

package day12;
/*
线程间通讯：
其实就是多个线程在操作同一个资源
但是操作的动作不同
*/
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(Exception e){}
this.name=name;
this.name=sex;
flag=true;
this.notify();
}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception 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","man");
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 InputOutputDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Res r=new Res();
//匿名对象形式
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/*
Input in=new Input(r);
Output out=new Output(r);
Thread t1=new Thread(in);
Thread t2=new Thread(out);
t1.start();
t2.start();
*/
}
}
/*
wait:
notify();
notifyAll();
都使用在同步中，因为要对持有监视器（锁）的线程操作
所以要使用在同步中，因为只有同步才具有锁
为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都不许要标识他们所操作线程持有的锁
只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒
不可以对不同锁中的线程进行唤醒
也就是说，等待和唤醒时同一个锁
而锁可以是任意对象，所以可以被任意对象调用的方法定义object类中
*/

2、等待唤醒机制 wait()与notify()

（1）wait()、notify()、notifyAll()

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。

notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

注意：sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

（2）为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？

（1）这些方法只存在于同步中；

（2）使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，也即是说等待和唤醒必须是同一个锁。

（3）而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

3、生产者与消费者

package day12;
/*
对于多个生产者和消费者
为什么要定义while判断标记
原因：让被唤醒的线程再次一次判断标记

为什么定义notifyAll
因为需要唤醒对方线程
因为只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待
*/
class ProducerConsumerDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
Resource r=new Resource();
Producer pro=new Producer(r);
Consumer con=new Consumer(r);

Thread t1=new Thread(pro);
Thread t2=new Thread(con);
Thread t3=new Thread(pro);
Thread t4=new Thread(con);
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)
try{wait();}catch(Exception e){}

this.name=name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"。。。生产者"+this.name);
flag=true;
this.notifyAll();
}
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"。。。......消费者"+this.name);
flag=false;
this.notifyAll();
}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
res.set("商品");
}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res=res;
}
public void run()
{
while(true)
{
res.out();
}
}
}

4、JDK1.5升级版本Lock和Condition

实现提供比synchronized方法和语句可获得的更广泛的锁的操作，可支持多个相关的Condition对象，Lock是个接口，锁是控制多个线程对共享数据进行访问的工具。

JDK1.5中提供了多线程升级的解决方案：将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。该对象可以Lock锁进行获取。

Lock的方法摘要：

void lock() 获取锁。

Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。

void unlock() 释放锁。

Condition方法摘要：

void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

void signal() 唤醒一个等待线程。

void signalAll() 唤醒所有等待线程。

四 线程的操作

1、停止线程

stop方法已经过时，如何停止线程？停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态

2、void interrupt() 中断线程: 中断状态将被清除，它还将收到一个 InterruptedException

3、setDaemon(boolean on) 守护线程（后台线程）

setDaemon(boolean on):将该线程标记为守护线程或者用户线程。

当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，在多线程里面主线程就是雅典娜，守护线程就是圣斗士，主线程结束了，守护线程则自动结束。当正在运行的线程都是守护线程时，java虚拟机jvm退出；所以该方法必须在启动线程前调用；

守护线程的特点：守护线程开启后和前台线程共同抢夺cpu的执行权，开启、运行两者都没区别，但结束时有区别，当所有前台线程都结束后，守护线程会自动结束。

package day12;
/*
Stop方法已经过时

如何停止线程？
只有一种，run方法结束
开启多线程运行，运行代码通常是循环结构

只要控制住循环，就可以让run方法结束，也就是线程结束

特殊情况：
当线程处于冻结状态。
就不会读取到标记，那么线程就不会结束

当没有指定的方式让冻结的线程回复到运行状态时，这时需要对冻结进行清除

强制让线程恢复到运行状态中来这样就可以操作标记让线程结束

Thread类提供该方法interrupt()

*/

class StopThread implements Runnable
{
private boolean flag=true;
public synchronized void run()
{
while(flag)
{
try
{
wait();
}
catch(InterruptedException e)
{
System.out.println(Thread.currentThread().getName()+"Exception");
flag=false;
}
System.out.println(Thread.currentThread().getName()+".....run");
}
}
public void changeFlag()
{
flag=false;
}
}

class StopThreadDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

StopThread st=new StopThread();

Thread t1=new Thread(st);
Thread t2=new Thread(st);

t1.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();

int num=0;
while(true)
{
if(num++==60)
{

//st.changeFlag();
//t1.interrupt();
//t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"........"+num);
}
System.out.println("over");
}

}

4、join 加入一个线程

void join() 等待该线程终止。

void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。throws InterruptedException

特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

作用: join可以用来临时加入线程执行；

5、多线程优先级：yield()方法

yield():暂停当前正在执行的线程对象，并执行其他线程

setPriority(int newPriority):更改线程优先级

int getPriority() 返回线程的优先级。

String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

(1)MAX_PRIORITY:最高优先级(10级)

(1)Min_PRIORITY:最低优先级(1级)

(1)Morm_PRIORITY:默认优先级(5级)

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