黑马程序员--多线程

黑马程序员--多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、定义

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

线程：进程中的一个独立的控制单元。线程在控制着进程的执行。 一个进程中至少有一个线程。

二、多线程作用

优点：多任务共同进行，防止后任务在一定时间内执行不到的问题发生。

弊端：线程如果太多，会导致效率降低。

多线程内部执行方式：

1、多线程运行结果的随机性：多线程中，线程间都会获取cpu的执行权，cpu执行到谁，谁就运行。

明确一点：某一时刻，只能有一个程序在运行（多核除外）。

2、cpu在做着快速的切换，已达到看上去是同时运行的效果。所以当线程过多时，cpu的切换次数会增多，

造成运行效率降低。所以，多线程的运行行为可看成互相抢夺cpu的执行权。

3、JVM 启动的时候会有一个进程 java.exe. 该进程中至少一个线程负责java程序的执行。

而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

4、JVM也是一个多线程。JVM运行不止启动一个主线程，还有负责启动垃圾回收机制。

三、自定义线程

1、线程运行状态：被创建、运行、临时状态、冻结、消亡五种状态。



2、创建线程方式：

第一种方式：继承Thread类。

步骤：

a、定义类继承Thread

b、复写Thread类中的run方法。原因：每个线程都有自己的目的性。JVM将创建的主线程任务定义在主函数中（main）。

run方法就是Java给用户用于创建自己任务的区域。

c、调用线程的start()。start()有两个作用：a、启动线程；b、让java虚拟机调用该函数的run方法。

//通过继承创建自己的线程
class Demo extends Thread
{
public void run()
{
for(int x=0;x<5;x++)
System.out.println("demo run--"+x);
}
}
class RunDemo
{
public static void main(String[] args)
{
//创建线程的目的：开启一条执行路径。可理解为抢夺资源。
Demo a = new Demo();

//开启线程并执行该线程的run方法。可理解为：赛跑的信号枪。
a.start();

//一般的对象调用方法。是一个强制性命令。系统会执行完run()后，再运行主函数。
//a.run();

for(int x=0;x<5;x++)
//用Thread类的getName()方法获取执行线程的名称。Thread.currentThread()==this;
System.out.println("Hellow World--"+x+this.getName());
}
}

多线程输出结果：



单线程执行结果：



第二种方式：实现Runnable接口。

该类实现run方法，然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。

步骤：

a、定义类实现Runnable接口

b、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。

c、通过Thread类建立线程对象。

d、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，

就必须明确该run方法所属对象。（让你儿子去打酱油，你必须告诉他超市在哪）

e、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

//实现Runnable，建立多线程
class Ticket implements Runnable //extends Thread
{
//此处可定义static让数据变成共享数据。但一般不定义static，因为其寿命太长。
private int tick = 100;
public void run()
{
//while(true)：无限循环，增加问题出现的可能性。
while(true)
{
if(tick>0)
{
//Thread.currentThread()：获取当前线程对象。getName():获取线程名称。
System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
}
}
}
}

class RunnableDemo
{
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();
}
}

输出结果：





这两种方式的区别：

区别：两种方式都自定义了run方法，但是它们的run方法存放的地点不一样。



继承Thread：线程代码存放Thread子类run方法中；实现Runnable:线程代码存在接口的子类的run方法。

相比较而言，实现Runnable的方法更好。因为它避免了类单继承的局限性。

四、多线程类的安全问题：

问题原因：共享数据时，一个线程对多条语句未全部执行完时，另一个线程参与进来，导致共同操作数据的情况。

解决措施：将存在多条语句的共享数据进行封装，一个线程在执行完共享数据前，其他线程不可以参与执行。

1、同步：是指两个或多个随时间变化的量在变化过程中保持一定的相对关系。它被用于封装代码，保障执行线程的唯一性。

同步的前提：

a、必须是多线程；（>=2个线程）

b、必须是同一把锁；

c、必须保证同步中只有一个线程在运行。

2、同步的种类：

a、同步代码块。跟函数一样用来封装代码，它比函数多了一个同步性。

synchronized(对象)

{

需要被同步的代码-->操作共享数据的语句

}

原理：对象如同锁。锁是一个公平的权限机制。它保障持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去。

优点：解决了多线程的安全问题； 弊端：多个线程需要判断锁，较消耗资源。

b、同步函数。赋予函数同步性。

public synchronized void add(){}

3、同步函数和同步代码块的区别：

a、同步函数的锁固定是this。因为函数需要被对象调用，那么函数都有一个所属对象引用-->this。

b、同步代码块的锁是任意对象。建议使用同步代码块，因为其针对性更强。

c、如果同步函数和同步代码块都使用this当锁，就可以实现同步。

d、静态的同步方法，使用的锁是该方法所在类的字节码文件对象（类名.class）

因为，静态用于成员的数据共享，它随着类的加载而加载。此时还没有创建对象，要保障锁的公平性就需要一个公有的事物，

类文件成为不二之选。

/*
同步代码块的锁是任意对象；
同步函数的锁是this；
静态的同步方法，使用的锁是该方法所在类的字节码文件对象：类名.class
*/
class Ticket implements Runnable
{
//加入静态，使tick成为成员共享数据
private static int tick = 100;
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
//同步代码块。这里的锁是：Ticket.class
synchronized(Ticket.class)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
}
}
}
}
else
while(true)
show();
}
//同步函数
public static synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....show:"+tick--);
}
}
}

class StaticDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
//休眠主函数，暂缓flag赋值，使得t1有机会执行。
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}

输出结果：





4、如何找出线程安全问题：

a、明确哪些代码是多线程运行代码；

b、明确共享数据；

c、明确多线程运行代码中哪些语句是操作共享数据的。两句以上最容易出错。

五、单例设计模式中的问题

懒汉式存在问题：懒汉式的特点在于实例的延时加载，这使得多线程访问时，会存在安全问题。

解决方法：加同步-->同步函数、同步代码块 加同步时，使用的锁是：该类所属的字节码文件对象（类名.class）

/*
单例设计模式：
饿汉式：就是先初始化对象。因为它内部的共享数据只有一条，不存在共同操作数据的情形，所以简单、安全。
懒汉式：方法被调用时，才建立对象（特点：存在延时加载）。
*/
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
//双重判断。可筛选数据，减少等待线程的数量，提高效率
if(s==null)
{
//静态 使用锁的是该方法所在类的字节码文件对象  类名.class
synchronized(Single.class)
{
if(s==null)
//延时加载，多线程访问时，此处线程可能处于临时状态（阻塞），造成安全隐患。
s = new Single();
}
}
return s;
}
}

六、死锁

死锁：因为嵌套锁且互相持有锁执行权，造成的僵持局面。

class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
//locka嵌套lockb
synchronized(MyLock.locka)
{
System.out.println("if A");
synchronized(MyLock.lockb)
{
System.out.println("if B");
}
}
}
}
else
{
while(true)
{
//lockb嵌套locka
synchronized(MyLock.lockb)
{
System.out.println("else B");
synchronized(MyLock.locka)
{
System.out.println("else A");
}
}
}
}
}
}
class MyLock
{
//创建两个对象，方便区别锁
static Object locka = new Object();
static Object lockb = new Object();
}

class DeadLockTest
{
public static void main(String[] args)
{
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}

输出结果：

七、线程间通讯--等待唤醒机制

等待唤醒机制：是统一资源分配和线程自我任务执行的协调机制。

1、涉及方法：

wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。

notify():随机唤醒线程池中的一个线程；

notifyAll():唤醒线程池中的所有线程。

2、以上方法使用前提：

a、都使用在同步中。因为这些方法要求线程必须拥有锁，而只有同步才具有锁。

b、wait()和notify()必须是同一把锁。

3、以上方法被定义在Object类中。因为锁可以是任意对象，所以将可以被任意对象调用的方法定义在Object类中。

/*
线程间通信:资源共享机制
注意：
1、本例有两个同步，因为有两个共同操作数据。
2、wait()、notify()、notyfyAll()被定义在Object类中。因为锁可以是任意对象，锁的方法具有通用性。
*/
class Res
{
//内部数据私有化
private String name;
private String sex;
private boolean flag = false;
//创建同步函数并初始化
public synchronized void set(String name,String sex)
{
if(this.flag)
//因为使用wait()会抛出中断异常，所以需要捕获、处理异常。
try{this.wait();}catch(Exception e){}
this.name = name;
this.sex = sex;
flag = true;
//唤醒先排队的线程
this.notify();
}
public synchronized void out()
{
if(!this.flag)
//this.wait()：标识等待线程，保证只能被对应对象唤醒，防止嵌套锁时，唤醒错误。
try{this.wait();}catch(Exception e){}
System.out.println(this.name+"....."+this.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("erwa","niangpao");
else
r.set("翠花","娘们儿");
//进行if、else切换
x = (x+1)%2;
}
}
}

class Output implements Runnable
{
private Res r;
//Input、Output都初始化r，保证了数据的唯一性。
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}
class InputOutputDemo
{
public static void main(String[] args)
{
//创建资源
Res r = new Res();
//创建线程、接收对象，并运行
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}

输出结果：



PS：

1、wait和死锁的区别：wait是全部放弃执行资格；死锁是全都有执行权，但陷入执行僵局。

2、notify()和notifyAll()区别：notify()唤醒线程池中先存入的wait对象；notifyAll():全部唤醒，不按存入顺序唤醒。

八、接口Lock

JDK1.5中提供了多线程升级解决方案：

a、用实现Lock代替同步synchronized操作；

b、用Condition对象替换wait、notify、notifyAll方法。它通过Lock锁进行获取。格式：Condition c = Lock.newCondition();

好处：

a、提供了显示的锁机制和显示的锁对象上的等待、唤醒操作机制。

b、同时将wait、notify成condition对象，使一个锁可以控制多个condition对象，这样我们就可以随意选择唤醒对象。

避免了之前一个锁对应一个wait、notify的情形，防止了死锁的发生。

//导入锁包
import java.util.concurrent.locks.*;

class Resource
{
private String name;
private int count = 1;
private boolean flag = false;

//创建锁
private Lock lock = new ReentrantLock();

//Condition()用于替代wait、notify、notifyAll
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();

public void set(String name)throws InterruptedException
{
//调用锁
lock.lock();
try
{
while(flag)
//生产者线程等待
condition_pro.await();
this.name = name+"..."+count++;

System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;
//唤醒消费者线程
condition_con.signal();
}
finally
{
//用finally保障一定会执行释放锁的动作。
lock.unlock();
}
}
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
//消费者线程等待
condition_con.await();
System.out.println(Thread.currentThread().getName()+"..........消费者..."+this.name);
flag = false;
//唤醒生产者线程
condition_pro.signal();
}
finally
{
lock.unlock();
}
}
}

class Producer implements Runnable
{
private Resource res;

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

Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch(InterruptedException e)
{
}
}
}
}
class ProducerConsumer2
{
public static void main(String[] args)
{
Resource r = new Resource();

Producer pro = new Producer(r);
Consumer con = new Consumer(r);

Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);

t1.start();
t2.start();
t3.start();
t4.start();
}
}

输出结果：

九、线程的停止

停止方式：让run方法结束；方法：控制循环。因为线程都是循环结构；特殊情况：interrupt()。

interrupt()：将处于冻结状态（中断状态）的线程，强制恢复到运行状态中来。注意：中断状态不是停止状态（stop）。

守护线程（后台线程）和前台线程的启动、运行都一样，只有结束不同-->当所有前台线程都结束后，后台线程会自动结束。

setDaemon():将该线程标记为守护线程或用户线程。就是后台线程、辅助线程。必须在启动线程前调用。

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)
{
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++ == 3)
{
//调用changeFlag()，改变循环，停止线程
st.changeFlag();

//interrupt()：将处于冻结状态的线程，强制恢复到运行状态中来。
//t1.interrupt();
//t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"....."+num);
}
System.out.println("over");
}
}

interrupt运行结果：



setDaemon输出结果：



PS：

1、join()：插队。它的加入会使主线程进入冻结状态，相当于插了主线程的队。

当A线程执行到了B线程的join()方法时，A线程就会等待，等B线程都执行完，A才会执行。

作用：用来临时加入线程执行。

2、toString():返回该线程的字符串形式，包括线程名称、优先级、线程组。

线程组：一般情况下，谁开启你的，谁就是你的线程组。

3、ThreadGroup():构造新新线程组。

优先级：代表抢cpu资源的频率。系统默认为5。

4、setPriority():设置线程优先级。MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY

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

十、小事例

/*
多线程的小事例:
当某些线程需要同时运行时，就将其单独封装，用多线程运行。
*/
class ThreadTest
{
public static void main(String[] args)
{
//用匿名内部类创建多线程对象
new Thread()
{
public void run()
{
for(int x = 0; x<10;x++)
{
System.out.println(Thread.currentThread().getName()+"...."+x);
}
}
}.start();

//用实现Runnable接口方式，创建线程
Runnable r = new Runnable()
{
public void run()
{
for(int x = 0; x<10;x++)
{
System.out.println(Thread.currentThread().getName()+"...."+x);
}
}
};
//创建线程，接收对象并运行
new Thread(r).start();

for(int x = 0; x<10;x++)
{
System.out.println(Thread.currentThread().getName()+"...."+x);
}
}
}

输出结果：