黑马程序员——Java语言--多线程

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

概述

首先先了解一下进程，进程：正在进行中的程序。（直译）

线程：就是进程中一个负责程序执行的控制单元（执行路径），一个进程中可以有多个执行路径，称之为——多线程。

            一个进程中至少有一个线程。

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

线程的状态

多线程的好处与弊端

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

弊端：线程太多会导致效率的降低。

其实应用程序的执行都是cpu在作者高速的切换完成的，这个切换是随机的。

多线程的创建方式

方式一：继承Thread类

      步骤：

定义一个类继承Thread类。
覆盖Thread类中的run方法。
直接创建Thread的子类对象创建线程。
调用start方法开启线程并调用线程的任务run方法执行。

创建线程的目的

是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。而运行的指定代码就是这个执行路径的任务。

JVM创建的主线程的任务都定义在了主函数中，而自定义的线程它的任务在哪儿呢？

Thread类用于描述线程，线程是需要任务的。所以Thread类也要对任务的描述。

这个任务就通过Thread类中的run方法来体现，也就是说，run方法就是封装自定义线程运行任务的函数。

开启线程是为了运行指定代码，所以只有继承Thread类，并覆写run方法。将运行的代码定义在run方法中即可。

Demo

class Demo extends Thread
{
private String name;

Demo(String name)
{
this.name = name;
}

// 覆盖run方法
public void run()
{
for(int x=0; x<10; x++)
{
System.out.println(name+" - x = " + x);
}
}
}

class ThreadDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo("哈哈");
Demo d2 = new Demo("小强");
d1.start(); // 开启线程并调用run方法
d2.start();
}
}

可以通过Thread的getName()获取线程的名称  Thread-编号（从0开始），主线程的名字就是main

class Demo extends Thread
{
private String name;

Demo(String name)
{
// super(name); 这里可以修改线程的名称
this.name = name;
}

// 覆盖run方法
public void run()
{
for(int x=0; x<10; x++)
{
System.out.println(name+" - x = " + x + "-" + Thread.currentThread().getName());
}
}
}

class ThreadDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo("哈哈");
Demo d2 = new Demo("小强");
d1.start(); // 开启线程并调用run方法
d2.start();
}
}

多线程运行图解

方式二：实现Runnable接口

步骤：

定义类实现Runnable接口
覆盖接口中的run方法，将线程的任务代码封装到run方法中
通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递，为什么呢？因为线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。如果不传递Runable子类对象，那么执行的就是Thread自己的run方法里的内容。
调用线程对象的start()方法开启线程并执行run方法。

Demo

class Demo implements Runnable // 如果Demo类已继承其他类（非Thread类），那么可以通过接口形式来完成
{
public void run()
{
show();
}

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

}

class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}

实现Runnable接口的好处：

将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成了对象。
避免了Java单继承的局限性。
所以，创建线程的第二种方式较为常用。

售票例子

/**
* 需求：卖票。
* 开启四个窗口进行售票，一共有100张票。
*/

class Ticket implements Runnable
{
private int num = 100;
public void run()
{
sale();
}

public void sale()
{
while(num > 0)
{
System.out.println(Thread.currentThread().getName() + "...ticket..." + num--);
}
}

}

class TicketDemo
{
public static void main(String[] args)
{
// 四个窗口共用一个Runnable的子类对象
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();

}
}

图解



以上的例子存在着线程安全隐患问题，有可能打印出错号票！

线程安全问题产生的原因

1、多个线程在操作共享的数据。

2、操作共享数据的线程代码有多条。

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

比如上面的例子，在判断了之后，切换到了另一个线程也判断通过了，在前面已通过的线程打印之后num就改变了，此时其他通过的线程可以使用到的num就是非法的了。

线程安全问题的解决思路——同步代码块（synchronized）

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

必须要当前线程把这些需要操作共享数据的代码执行完成之后，其他线程才可以参与运算。

在Java中，用同步代码块就可以解决这个问题。

同步代码块的格式：

synchronzied(对象)

{

        需要被同步的代码;

}

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

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

同步的前提：同步中必须有多个线程并使用同一个锁，否则可能还会有问题。

对上面的售票例子通过同步代码块来解决

/**
* 需求：卖票。
* 开启四个窗口进行售票，一共有100张票。
*/

class Ticket implements Runnable
{
private int num = 100;
Object obj = new Object();

public void run()
{
sale();
}

public void sale()
{
while(true)
{
// 使用同步代码块，obj相当于一个锁
synchronized(obj)
{
//这里让线程睡眠10毫秒，是想看到打印错票的情况
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
if(num > 0)
System.out.println(Thread.currentThread().getName() + "...ticket..." + num--);
}
}
}

}

class TicketDemo
{
public static void main(String[] args)
{
// 四个窗口共用一个Runnable的子类对象
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();

}
}

同步函数

/**
* 需求：储户，两个。每个都到银行存钱，每次存100块，共存三次。
*/

class Bank
{
private int sum;
// private Object obj = new Object(); // 锁
// 将synchronized作为函数的修饰符使用，同步函数
public synchronized void add(int num)
{
//synchronized(obj)
//{
sum += num;
// 如果不使用同步，那么在这会有安全隐患
//try
//{
//	Thread.sleep(10);
//}
//catch (InterruptedException e)
//{
//	e.printStackTrace();
//}
System.out.println("sum = " + sum);
//}
}
}

class Cus implements Runnable
{
private Bank b = new Bank();
public void run()
{
for(int x=0; x<3; x++)
{
b.add(100);
}
}
}

class BankDemo
{
public static void main(String[] args)
{
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}

同步函数使用的锁是：this。
同步函数和同步代码块的区别：同步函数的锁是固定的this。同步代码块的锁是任意的对象。

建议使用同步代码块。

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

单例模式涉及的多线程问题

//饿汉式
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 Demo implements Runnable
{
public boolean flag;
Demo(boolean flag)
{
this.flag = flag;
}

public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName() + "  if locka.....");
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName() + "  if lockb.....");
}
}
}
}else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName() + "  else lockb.....");
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName() + "  else locka.....");
}
}
}
}
}
}

class MyLock
{
public static final Object locka = new Object();
public static final Object lockb = new Object();
}

class DeadLockDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo(false);
Demo d2 = new Demo(true);
Thread t1 = new Thread(d1);
Thread t2 = new Thread(d2);
t1.start();
t2.start();
}
}

线程间通信

示例

实现两个线程之间的通信，一个线程负责给资源添加数据，另一个线程在资源那获取数据。

class Resource
{
String name;
String sex;
}

class Input implements Runnable
{

// 接收操作的资源的地址
private Resource r;
Input(Resource r)
{
this.r = r;
}

public void run()
{
boolean flag = true;
while(true)
{
// 加上同步，是因为可能赋值赋到给name的时候
//线程就切换到了输出了，那么sex还没有赋值，这就会出现name和sex不对应的错误
synchronized(r)
{
if(flag)
{
r.name = "hazy";
r.sex = "boy";
flag = false;
}
else
{
r.name = "小赖";
r.sex = "女女女女女女";
flag = true;
}
}
}
}
}

class Output implements Runnable
{
// 接收操作的资源的地址
private Resource r;
Output(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
{
// 因为资源类是唯一的，并且输入和输出操作的是同一个资源对象，那么可以作为同步锁
synchronized(r)
{
System.out.println(r.name + " ...... " + r.sex);
}
}
}

}

class ResourceDemo
{
public static void main(String[] args)
{
// 创建资源
Resource r = new Resource();
// 创建任务
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()：让线程处于冻结状态，被wait的线程会被存储在线程池中。
notify()：唤醒线程池中的一个线程（任意）。
notifyAll()：唤醒线程池中的所有的线程。
这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。

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

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

Demo：

class Resource
{
String name;	// 姓名
String sex;		// 性别
boolean flag = false;	// 用于判断是否输入数据，是否输出数据
}

class Input implements Runnable
{

// 接收操作的资源的地址
private Resource r;
Input(Resource r)
{
this.r = r;
}

public void run()
{
boolean flag = true;
while(true)
{
// 加上同步，是因为可能赋值赋到给name的时候
//线程就切换到了输出了，那么sex还没有赋值，这就会出现name和sex不对应的错误
synchronized(r)
{
// 如果是true，那么说明已经输入了数据了，当前线程等待状态，让输出线程进行输出
// 等输出之后，在输出代码那里对这里的等待进行唤醒，重新输入数据
if(r.flag)
{
try
{
r.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
if(flag)
{
r.name = "hazy";
r.sex = "boy";
flag = false;
}
else
{
r.name = "小赖";
r.sex = "女女女女女女";
flag = true;
}
r.flag = true;	// 当输入了数据之后，重新置为等待状态
r.notify(); // 唤醒输出线程，进行输出
}
}
}
}

class Output implements Runnable
{
// 接收操作的资源的地址
private Resource r;
Output(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
{
// 因为资源类是唯一的，并且输入和输出操作的是同一个资源对象，那么可以作为同步锁
synchronized(r)
{
// 如果输出了，那就等待输入线程输入
if(!r.flag)
{
try
{
r.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
System.out.println(r.name + " ...... " + r.sex);
r.flag = false;	// 输出了，置为等待
r.notify();		// 唤醒输入线程
}
}
}

}

class ResourceDemo
{
public static void main(String[] args)
{
// 创建资源
Resource r = new Resource();
// 创建任务
Input in = new Input(r);
Output out = new Output(r);
// 创建线程，执行路径。
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
// 开启线程
t1.start();
t2.start();
}
}

代码优化

class Resource
{
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)
{
e.printStackTrace();
}
}
this.name = name;
this.sex = sex;
flag = true;
notify();
}

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

class Input implements Runnable
{

// 接收操作的资源的地址
private Resource r;
Input(Resource r)
{
this.r = r;
}

public void run()
{
boolean flag = true;
while(true)
{
if(flag)
{
r.set("hazy", "boy");
flag = false;
}
else
{
r.set("小赖", "女女女女女女");
flag = true;
}
}
}
}

class Output implements Runnable
{
// 接收操作的资源的地址
private Resource r;
Output(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
{
r.out();
}
}

}

class ResourceDemo2
{
public static void main(String[] args)
{
// 创建资源
Resource r = new Resource();
// 创建任务
Input in = new Input(r);
Output out = new Output(r);
// 创建线程，执行路径。
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
// 开启线程
t1.start();
t2.start();
}
}

多生产者，多消费者问题

使用多线程实现多个生产者，多个消费者交替执行生成和消费功能。

假如有两个生产者，两个消费者，如果生产者还未有生产产品，那么消费者不能进行消费，所以在资源里有一个flag标记是否生产了（或者说是否有产品），

有一个生成者生成了产品，此时只能给执行权只能给两个消费者进行抢夺，所以用了while来判断flag。

但是仅有while在唤醒后做判断是不够的，因为notify唤醒的是线程池里任意一个线程，有可能消费者都在等待状态，生产者生产了之后唤醒的还是生产者，有可能出现死锁，所以使用notifyAll代替notify可以解决问题。

/**
* 生产者，消费者
*
* 多生产者，多消费者的问题。
* if判断标记，只有一次，会导致不该运行的线程运行了，出现数据错误的情况。
* while判断标记，解决了线程获取执行权后，是否运行。
*
* notify：只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁的出现。
* notifyAll：解决了该问题，本方线程一定会唤醒对方线程。
*/

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

// 输入
public synchronized void set(String name)
{
// 当线程被唤醒之后，重新判断flag
while(flag)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
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)
{
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "...........消费者...消费" + this.name);
flag = false;
notifyAll();
}
}

class Producer implements Runnable
{
private Resource r;

Producer(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
r.set("烤鸭");
}
}

class Consumer implements Runnable
{
private Resource r;

Consumer(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
r.out();
}

}

class  ProducerConsumerDemo
{
public static void main(String[] args)
{
// 创建资源
Resource r = new Resource();
// 创建任务
Producer p = new Producer(r);
Consumer c = new Consumer(r);
// 创建线程
Thread t0 = new Thread(p);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
Thread t3 = new Thread(c);

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

多生产者多消费者-jdk1.5解决方法

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

Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式锁操作变成显式锁操作。同时更为灵活，可以一个锁上加上多组监视器。

Condition接口：出现替代了Object中的wait、notify、notifyAll方法，将这些监视器的方法单独进行了封装，变成Condition监视器对象，可以和任意锁组合。

await();代替wait();

signal();代替notify();

signalAll();代替notifyAll();

这里使用Lock对象代替了synchronized同步代码块，使用Condition对象代替了监视器，以往都是使用一个锁来进行监视多个线程，现在可以通过lock锁来实例化多个监视器，对不同线程或者说不同觉得进行监视。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class Resource
{
private String name;
private int count = 1;

// 实例化一个互斥锁
private Lock lock = new ReentrantLock();
// 通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
private Condition producer_con = lock.newCondition(); // 生产者监视器
private Condition consumer_con = lock.newCondition(); // 消费者监视器

// 标记是否生产，是否消费
private boolean flag = false;

public void set(String name)
{
lock.lock();	// 获取锁
try
{
while(flag)
{
try
{
producer_con.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName() + ".............生产者5.0...." + this.name);
flag = true;
// 产品生产了之后，唤醒消费者来进行消费，所以使用消费者监视器
consumer_con.signal();	// 任意叫一个即可
}
finally
{
lock.unlock();	// 释放锁
}
}

public void out()
{
lock.lock();	// 获取锁

try
{
// 如果已经消费了，那么当然就是等待生产啦
while(!flag)
{
try
{
consumer_con.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 被唤醒了，当然就是开始消费啦，消费了之后，再当然叫生产者继续生产啦
System.out.println(Thread.currentThread().getName() + "...消费者5.0..." + this.name);
flag = false; // 消费了就等待生成
producer_con.signal(); // 唤醒一个生产者进行生产
}
finally
{
lock.unlock();
}
}
}

// 生产者
class Producer implements Runnable
{
private Resource r;
Producer(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
{
r.set("烤鸭");
}
}
}

// 消费者
class Consumer implements Runnable
{
private Resource r;
Consumer(Resource r)
{
this.r = r;
}

public void run()
{
while(true)
{
r.out();
}
}
}

class ProducerConsumerDemo2
{
public static void main(String[] args)
{
// 创建资源
Resource r = new Resource();
// 创建生产者和消费者
Producer p = new Producer(r);
Consumer c = new Consumer(r);
// 创建线程
Thread t0 = new Thread(p);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
Thread t3 = new Thread(c);
// 开启线程
t0.start();
t1.start();
t2.start();
t3.start();

}
}

sleep和wait的区别

1、wait可以指定时间，也可以不指定。

      sleep必须指定时间。

2、在同步中时，对cpu的执行权和锁的处理不同。

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

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

停止线程的方式

1、stop方法。

2、run方法结束。

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

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

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

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

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中，让线程具备cpu的执行资格。

但是强制动作会发生InterrupedException异常，需要进行处理。可以在interrupt()后，让线程读取标记。

class StopThread implements Runnable
{
// 标记，决定线程的结束的，也就是决定run方法执行的代码是否结束
private boolean flag = true;

public synchronized void run()
{
while(flag)
{
try
{
wait();
}
catch (InterruptedException e)
{
System.out.println(Thread.currentThread().getName() + ".........." + e);
setFlag(false); // interrupt后发生异常，然后更改标记，让线程读取
}

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

public void setFlag(boolean f)
{
this.flag = f;
}
}

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.start();

int num = 1;
for(;;)
{
if(num==50)
{
t1.interrupt();
t2.interrupt();
break;
}
System.out.println("thread..main..." + num++);
}

}
}