本文主要是介绍黑马程序员——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。同步代码块的锁是任意的对象。
建议使用同步代码块。
静态的同步函数使用的锁是 该函数所属字节码文件对象，可以用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){// 当线程被唤醒之后，重新判断flagwhile(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++);}}
}
这篇关于黑马程序员——Java语言--多线程的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
