多线程

关于多线程有关的概念：

进程：进程指正在运行的程序，并且具有一定独立功能
线程：线程是进程中的一个执行单位，负责当前进程程序的执行，一个进程中至少会有一个线程，如果一个进程中包含多个线程，那么可称为多线程程序
单线程：当要执行多个任务时，cpu只会依次执行，当一个任务执行完后，再去执行另外一个任务
多线程：多个任务可以同时进行

在Java中，不同线程会有不同的优先级抢占cpu，如果线程优先级相同，就会随机先去一个线程去执行

Java程序运行时会默认执行3个进程：

main主线程
gc垃圾回收机制
异常处理机制

我们如何能够判断程序是否是多线程？

如果我们能够将程序的执行用一条直线画出来，就说明是单线程

关于线程的常用API方法

run（）：该方法需要被重写，重写的内容就是需要执行的操作
start（）：调用该方法就会启动相应的线程，并调用当前线程的run方法
sleep（long millitime）：将当前线程进入阻塞状态（不会释放锁，即同步监视器）
join（）：当a线程调用b线程的join方法时，a线程会进入阻塞状态，直到b线程的任务执行完毕
isAlive（）：判断当前线程是否存活
yield（）：调用该方法后回释放当前线程的cpu执行权，当时并不代表不会再次执行，有可能释放后，又是该线程抢占到了cpu的执行权
currentThread（）：Thread类中的静态方法，会返回执行当前程序的线程
getName（）：返回当前线程的名字
setName（）：设置线程的名字
getPriority（）：设置线程的优先级（

MAX_PRIORITY=10

MIN_PRIORITY=1

NORM_PRIORITY=5 默认优先级

wait（）：将线程进入阻塞状态（会释放掉锁），只能在同步代码块或同步方法中使用
notify（）：将另外一个线程唤醒
notifyAll（）：唤醒所有被阻塞的线程

线程创建的4种方式

一：继承Thread类

首先创建一个类去继承Thread
重写Thread中的run方法
main（）中创建该对象
调用该对象的start方法，启动线程

public class test {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        myThread1.start();
    }
}
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("继承了Thread");
    }
}

二：实现Runnable接口

创建一个类实现Runnable接口
实现接口的run方法
在main（）中创建实现Runnable的对象
创建Thread对象，并把刚创建好的类传参
调用Thread对象的start方法，启动线程

public class test {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        Thread t=new Thread(myThread1);
        t.start();
    }
}
class MyThread1 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现了Runnable");
    }
}

三：实现Callable接口

创建一个类实现Callable接口
实现接口的call（）方法
在main中创建实现Callable的对象
创建FutureTask对象并把上面创建的对象传参
创建Thread对象，传入FutureTask对象
调用Thread的start方法，启动线程

public class test {
    public static void main(String[] args) {
        MyThread2 myThread2=new MyThread2();
        FutureTask futureTask=new FutureTask(myThread2);
        Thread t=new Thread(futureTask);
        t.start();
    }
}
class MyThread2 implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println("实现了Callable");
        return null;
    }
}

此方式如果需要得到返回值需要调用futureTask.get();

但是会抛异常，用try，catch方法捕捉一下就好了

四：线程池

创建ExecutorService对象
传入相应的线程对象
结束线程池

public class test {
    public static void main(String[] args) {
        //创建线程池，设置线程池线程的数量为10
        ExecutorService service = Executors.newFixedThreadPool(10);
        //execute适用于实现了Runnable的对象
        service.execute(new MyThread1());
        //submit适用于实现了Callable的对象
        service.submit(new MyThread2());
        //结束线程池
        service.shutdown();
    }
}
class MyThread1 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现了Runnable");
    }
}
class MyThread2 implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println("实现了Callable");
        return null;
    }
}

Runnable和Callable的对比：

Callable可以有返回值，执行完相应操作后可以返回需要的结果
可以抛异常，可以将call方法中的异常抛出
支持泛型，可以指定返回值类型

线程安全

什么是线程安全问题呢？

当多个线程对同一个共享数据操作时，线程执行还没来得及更新处理共享的数据，从而使得其他操作的线程并未得到最新的数据，从而产生问题

举个例子：

当甲乙两人向同一账户存钱，让甲乙两个线程同时存钱，如果甲向账户存了1000元，并打印此时余额，应为1000元，但是如果此时乙也存了1000元，就会导致，显示余额为2000元，并不是甲当时的余额
还有就是火车售票问题，如果多个窗口同时售票，如果1号窗口正在卖001号票时，此时还未处理完成，这是2号窗口也卖了001号票，这就导致产生了两个001号票

那么如何解决呢？

有三种方式：

方法一：同步代码块

synchronized(Object obj)
{
  //操作内容                
}

synchronized（）：传入的可以是任意类的对象，但必须是多个线程共用的，一般可以利用this，即当前对象（Runnable），Thread不太行，因为继承多个Thread类会导致this对象不一致
被包住的代码执行为单线程，当一个线程执行完后，另外一个线程才有可能会分配到执行权去执行
多个线程必须共用同一把锁，这样才能够判断一个线程是够执行
Runnable一般很实用，因为多个线程都调用同一个类的方法，但是Thread就需要自己定义静态变量或者当前的唯一类即（windows.class）

public class test {
    public static void main(String[] args) {
        Window t1 = new Window("窗口1");
        Window t2 = new Window("窗口2");
        Window t3 = new Window("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window extends Thread{
    private static int ticket=100;
    //继承方式，要用静态对象，因为继承实现多线程有多个对象，不是共用一个对象
    private static Object obj=new Object();
    public Window(String name){
        super(name);
    }
    @Override
    public void run() {
        while(true){
            //不可以用this，同理，因为有很多对象，不唯一
            synchronized(obj){
                if(ticket>0){
                    System.out.println(getName()+":卖票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

方法二：同步方法

和同步代码块类似

就是将共享数据的操作封装成方法

将这个方法用锁锁住

public class test {
    public static void main(String[] args) {
        Window t1 = new Window("窗口1");
        Window t2 = new Window("窗口2");
        Window t3 = new Window("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window extends Thread{
    private static int ticket=100;
    public Window(String name){
        super(name);
    }
    @Override
    public void run() {
        while(true){
            show();
        }
    }
    public static synchronized void show(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
            ticket--;
        }
    }
}

注意：

show方法要定义成静态，因为如果是非静态，它的锁默认是当前对象，继承方式就会有多个锁，如果是Runnable就可以，所以需要编程静态，这样默认锁就是当前类对象

方法三：lock锁

首先创建一个ReentrantLock对象
在执行共享数据之前将锁打开，调用lock方法
在结束时将锁解开，调用unlock方法

public class test {
    public static void main(String[] args) {
        Windows w = new Windows();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Windows implements Runnable{
    private int ticket=100;
    private ReentrantLock lock=new ReentrantLock(true);
    @Override
    public void run() {
        while(true){
            try {
                lock.lock();
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

问题：该方式和synchrnized有什么不同呢？

synchronized在执行完相应代码后会自动上锁解锁，而lock需要手动上锁和解锁，较为灵活

线程的死锁

描述：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

举个例子：两个人迎面相遇，甲希望乙会给他让路，而乙希望甲给他让他让路，就这样两个人僵持在这里，最终谁也不给谁让路，导致死锁问题

public class test {
    public static void main(String[] args) {
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

本例中，线程1首先拿到了s1锁，然后阻塞了一段时间，这段时间线程2拿到了s2锁，这是线程1就绪需要s2锁，而线程2需要s1锁，两者谁都拿不到，就会僵持住

解决死锁的相应办法：

减少共享变量的使用
设计相应的算法去规避死锁问题
尽量减少锁的嵌套使用

线程的通信

wait（）：将线程进入阻塞状态（会释放掉锁），只能在同步代码块或同步方法中使用
notify（）：将另外一个优先级高的线程唤醒
notifyAll（）：唤醒所有被阻塞的线程

注意：这三个方法只能够在同步代码块或者同步方法使用，都定义在了Object类中

例题要求：

让两个线程交替打印1-100之间的数字

public class 线程通信 {
    public static void main(String[] args) {
        Number number=new Number();
        Thread t1=new Thread(number);
        Thread t2=new Thread(number);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}
class Number implements Runnable{
    private int number=1;
    @Override
    public void run() {
        while(true){
            synchronized (this) {
                notify();
                //唤醒全部
                // notifyAll();
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //使得调用如下方法进程阻塞,执行wait后，锁就被释放
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

当线程1首次进入，会打印出1，然后调用了wait方法，进入阻塞状态
此时线程2进入，首先会唤醒线程1，然后打印2，然后自己进入阻塞状态
两者交替阻塞唤醒，直到打印完为止

那么问题是sleep和wait方法有什么异同？

两个方法声明的位置不同，sleep是Thread中声明的，而wait是Object中声明的

sleep可以在任何情景调用，而wait只能够在同步代码块或同步方法中使用

sleep执行后不会释放当前的锁，而wait会释放掉当前的锁

生产者和消费者问题：

生产者（Priductor）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品（比如20个），如果生产者视图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产：如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

package 生产者与消费者问题;
public class 生产者 {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1 = new Producer(clerk);
        p1.setName("生产者");
        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者");
        p1.start();
        c1.start();
    }
}
class Clerk{
    private int productCount=0;
    public synchronized void consumeProduct() {
        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void produceProduct() {
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{
    private Clerk clerk;
    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品......");
        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}
class Consumer extends Thread{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品......");
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

生产者和消费者会共享产品数量
我们可以在售货员类中定义方法，当此时的生产数量未达到标准时，就会进行生产，然后会唤醒消费的进程，否则就会进入阻塞状态
而当产品数量不足时，消费者就会唤醒生产进程，此时，自己进入阻塞状态

Java多线程与并发框（完结篇）——再看不懂我找不到女朋友

多线程

关于线程的常用API方法

线程创建的4种方式

一：继承Thread类

二：实现Runnable接口

三：实现Callable接口

四：线程池

Runnable和Callable的对比：

线程安全

方法一：同步代码块

方法二：同步方法

方法三：lock锁

线程的死锁

线程的通信

生产者和消费者问题：

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java多线程与并发框（完结篇）——再看不懂我找不到女朋友

关于线程的常用API方法

线程创建的4种方式

一：继承Thread类

二：实现Runnable接口

三：实现Callable接口

四：线程池

Runnable和Callable的对比：

线程安全

方法一：同步代码块

方法二：同步方法

方法三：lock锁

线程的死锁

线程的通信

生产者和消费者问题：

热门文章

最新文章

相关课程

相关电子书

相关实验场景