Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

进程和线程

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

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

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

Java VM 启动的时候会有一个进程java.exe.

该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

创建线程的第一种方式-继承Thread类

步骤：

1. 定义类继承Thread。

2. 复写Thread类中的run方法。

   目的：将自定义代码存储在run方法。让线程运行。

3. 调用线程的start方法，

   该方法两个作用：启动线程，调用run方法。

public class ThreadDemo {    public static void main(String[] args) {        Demo d = new Demo();//创建好一个线程。        d.start();//开启线程并执行该线程的run方法。        for (int x = 0; x < 60; x++)            System.out.println("Hello World!--" + x);    }}class Demo extends Thread {    @Override    public void run() {        for (int i = 0; i < 60; i++) {            System.out.println("demo run----" + i);        }    }}

发现运行结果每一次都不同。

因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。 明确一点，在某一个时刻，只能有一个程序在运行。(多核除外) cpu在做着快速的切换，以达到看上去是同时运行的效果。 我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。

为什么要覆盖run方法呢？

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

线程的运行状态

练习：创建两个线程，和主线程交替运行

class Test extends Thread {    Test(String name) {        super(name);    }    public void run() {        for (int x = 0; x < 60; x++) {            System.out.println((Thread.currentThread() == this) + "..." + this.getName() + " run..." + x);        }    }}public class ThreadTest {    public static void main(String[] args) {        Test t1 = new Test("one---");        Test t2 = new Test("two+++");        t1.start();        t2.start();        for (int x = 0; x < 60; x++) {            System.out.println("main....." + x);        }    }}

线程都有自己默认的名称。

Thread-编号 该编号从0开始。

• static Thread currentThread():获取当前线程对象。
• getName(): 获取线程名称。
• 设置线程名称：setName或者构造函数。

创建线程的第二种方式-实现Runnable接口

/** * 需求：简单的卖票程序。 * 多个窗口同时买票。 */public class TicketDemo {    public static void main(String[] args){        Ticket t = new Ticket();        Thread t1 = new Thread(t);//窗口1        Thread t2 = new Thread(t);//窗口2        Thread t3 = new Thread(t);//窗口3        Thread t4 = new Thread(t);//窗口4        t1.start();        t2.start();        t3.start();        t4.start();    }}class Ticket implements Runnable {    private int ticket = 500;    @Override    public void run() {        while (ticket > 0) {            System.out.println(Thread.currentThread().getName() + "----sale:" + ticket--);        }    }}

步骤：

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方法。

多线程的安全问题

上面的买票程序，加入线程等待

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

可能会出现0，-1，-2号票，多线程的运行出现了安全问题。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，

另一个线程参与进来执行。导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

多线程同步代码块

Java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块。

synchronized(对象){    需要被同步的代码}

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

上面的买票问题加入同步代码块之后：

/** * 需求：简单的卖票程序。 * 多个窗口同时买票。 */public class TicketDemo {    public static void main(String[] args){        Ticket t = new Ticket();        Thread t1 = new Thread(t);//窗口1        Thread t2 = new Thread(t);//窗口2        Thread t3 = new Thread(t);//窗口3        Thread t4 = new Thread(t);//窗口4        t1.start();        t2.start();        t3.start();        t4.start();    }}class Ticket implements Runnable {    private int ticket = 500;    Object obj = new Object();    @Override    public void run() {        while (true) {            synchronized (obj){                if (ticket>0){//                    try {//                        Thread.sleep(10);//                    } catch (InterruptedException e) {//                        e.printStackTrace();//                    }                    System.out.println(Thread.currentThread().getName() + "----sale:" + ticket--);                }            }        }    }}

同步的前提：

1. 必须要有两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。

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

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

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

同步函数的锁是this

函数需要被对象调用。那么函数都有一个所属对象引用。就是this。

所以同步函数使用的锁是this。

通过该程序进行验证。

使用两个线程来买票。

一个线程在同步代码块中。 一个线程在同步函数中。 都在执行买票动作。

class Ticket implements Runnable{    private  int tick = 100;    Object obj = new Object();    boolean flag = true;    public  void run()    {        if(flag)        {            while(true)            {                synchronized(this)                {                    if(tick>0)                    {                        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 t = new Ticket();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        t1.start();        try{Thread.sleep(10);}catch(Exception e){}        t.flag = false;        t2.start();    }}

静态同步函数的锁是class对象

如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不在是this。因为静态方法中也不可以定义this。

静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class 该对象的类型是Class

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

class Ticket2 implements Runnable {    private static int tick = 100;    //Object obj = new Object();    boolean flag = true;    public void run() {        if (flag) {            while (true) {                synchronized (Ticket.class) {                    if (tick > 0) {                        try {                            Thread.sleep(10);                        } catch (Exception e) {                        }                        System.out.println(Thread.currentThread().getName() + "....code : " + 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 StaticMethodDemo {    public static void main(String[] args) {        Ticket2 t = new Ticket2();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        t1.start();        try {            Thread.sleep(10);        } catch (Exception e) {        }        t.flag = false;        t2.start();    }}

死锁

同步中使用的锁不一样，就会造成死锁

class Test implements Runnable {    private boolean flag;    Test(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 {    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();    }}

线程间通信

其实就是多个线程在操作同一个资源，

但是操作的动作不同。

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.sex = 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 InputOutputDemo2 {    public static void main(String[] args) {        Res r = new Res();        new Thread(new Input(r)).start();        new Thread(new Output(r)).start();            }}

等待唤醒机制

wait:

notify(); notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。

所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁， 只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。 不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

思考1:wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中?

1. 这些方法存在与同步中。
2. 使用这些方法时必须要标识所属的同步的锁。
3. 锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

思考2:wait(),sleep()有什么区别?

wait():释放cpu执行权，释放锁。

sleep():释放cpu执行权，不释放锁

生产者消费者问题

方法一：

class ProducerConsumerDemo {    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();    }}class Resource {    private String name;    private int count = 1;    private boolean flag = false;    //  t1    t2    public synchronized void set(String name) {        while (flag)            try {                this.wait();            } catch (Exception e) {            }//t1(放弃资格)  t2(获取资格)        this.name = name + "--" + count++;        System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);        flag = true;        this.notifyAll();    }    //  t3   t4      public synchronized void out() {        while (!flag)            try {                wait();            } catch (Exception e) {            }//t3(放弃资格) t4(放弃资格)        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();        }    }}

对于多个生产者和消费者。

为什么要定义while判断标记。 原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，

因为需要唤醒对方线程。

方法二：

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

将同步Synchronized替换成现实Lock操作。 将Object中的wait，notify notifyAll，替换了Condition对象。 该对象可以Lock锁 进行获取。 该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized

lock unlock newCondition()

Condition：替代了Object wait notify notifyAll

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

import java.util.concurrent.locks.*;class ProducerConsumerDemo2 {    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();    }}class Resource {    private String name;    private int count = 1;    private boolean flag = false;    //  t1    t2    private Lock lock = new ReentrantLock();    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();//t1,t2            this.name = name + "--" + count++;            System.out.println(Thread.currentThread().getName() + "...生产者.." + this.name);            flag = true;            condition_con.signal();        } finally {            lock.unlock();//释放锁的动作一定要执行。        }    }    //  t3   t4      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) {            }        }    }}

停止线程

如何停止线程？

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

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

1. 定义循环结束标记

   因为线程运行代码一般都是循环，只要控制了循环即

2. 使用interrupt(中断)方法。

   该方法是结束线程的冻结状态，使线程回到 运行状态中来。

注:stop方法已经过时不再使用。

线程类的其他方法

• setPriority(int num)
• setDaemon(boolean b)
• join()
• 自定义线程名称
• toString()