13.多线程

一.线程
1.定义：能够独立运行程序的资源，理论上可以多线程并发运行
2.进程和线程的区别：进程是针对操作系统而言的，一个进程就是一个程序在后台运行，可以多进程并发运行。
一个进程可以包含多个线程
3.线程的实现方式：
a.写一个类继承Thread类，重写其run(); 调用该实例的start()启动线程
b.写一个类实现Runable接口，重写run();通过Thread(Runable)构造一个线程类，再调用start()
c.见案例demo1

4.线程的生命周期
a.新生：创建线程的实例
b.运行中：
运行正常
阻塞状态：睡眠（会自己醒来），IO阻塞（必须等到唤醒），等待锁状态（一定要拿到对象锁才会执行），唤醒

5.Thread的常用API
start 启动线程
sleep 睡眠，会自定唤醒，
currentThread()：获取当前线程的引用
interrupt()：中断线程 代替stop方法
setPriority(int newPriority)：设置优先级
yield() ：礼让，把cpu的资源放弃让其他线程占有

Object中对线程的操作：
wait：是将该对象上正在执行的线程阻塞，挂起，不能自己唤醒
notify：将该对象上阻塞的线程唤醒，此方法之唤醒一个线程
notifyall：就是将该对象上所有挂起的线程全部唤醒

6.多线程操作：
a.每个对象都有对象锁，多线程安全就是让线程获得该对象的对象锁
b.其实现就是用同步关键字：synchronized
c.同步关键字的用法：可以用在方法和代码块

练习1：
创建两个线程：线程1每隔一秒执行一次，打印输出奇数（1-100）
线程2每隔一秒执行一次，打印输出偶数（1-100）
线程1：1
线程2：2

7.例子

　　创建线程举例：

package com.hwua.myThread;

public class Demo1 extends Thread{
    @Override
    public void run() {
        //此方法是核心方法，线程运行就是执行该方法
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("线程1：你好");
    }
    
    public static void main(String[] args) {
        
    }
}

/**
 * 线程实现的第一种方式
 * @author allen
 *
 */
class Demo2 extends Thread{
    public void run() {
        //此方法是核心方法，线程运行就是执行该方法
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("线程2：你好，吃饭了没");
    }
}

/**
 * 线程实现的第二种方式
 * @author allen
 *
 */
class Demo3 implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("线程3：吃没吃饭管你什么事？");
    }
    
}

class Test{
    public static void main(String[] args) {
        Thread demo1 = new Demo1();
        Thread demo2 = new Demo2();
        Thread demo3 = new Thread(new Demo3());
        demo1.setPriority(10);//设置线程的优先级，但是优先级不具有具有绝对性，低优先级仍有机会执行只是概率变小
        demo1.start();//该方法是启动线程的唯一方法
        demo2.start();
        demo3.start();
    }
}

　　线程同步到方法上举例：

package com.hwua.myThread;
/**
 * 线程同步案例。多线程访问同一资源的问题
 * 线程安全是同步的过程
 * 线程非安全是异步的过程
 * @author allen
 *
 */
public class SynchronizDemo {
    public static void main(String[] args) {
        UserInfo user = new UserInfo();
        Thread a = new A(user);
        Thread b = new B(user);
        a.start();
        b.start();
    }
}

class A extends Thread{
    UserInfo user;//让多个线程公用同一个对象
    public A(UserInfo user) {
        this.user = user;
    }
    @Override
    public void run() {
        user.getMoney(1000);
    }
}

class B extends Thread{
    UserInfo user;//让多个线程公用同一个对象
    public B(UserInfo user) {
        this.user = user;
    }
    @Override
    public void run() {
        user.getMoney(1000);
    }
}


class UserInfo{
    private double balance = 1000;//余额

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    /**
     * money：要取得数量
     */
    public synchronized int getMoney(double money){
        if(money>balance){
            System.out.println("余额不足！不能取");
            return -1;
        }else{
            try {
                Thread.currentThread().sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            balance -= money;
            System.out.println("取款成功，取了："+money+",余额："+balance);
            return 1;
        }
    }
}

　　线程死锁举例：

package com.hwua.myThread;

public class DeathThreadDemo {
    public static void main(String[] args) {
        Thread aa = new AA();
        Thread bb = new BB();
        aa.start();
        bb.start();
    }
}

class Stu1 {
    
}

class Stu2 {
    
}

class AA extends Thread{
    @Override
    public void run() {
        synchronized (Stu1.class) {//该线程获取Stu1的对象锁
            System.out.println("线程AA：获取Stu1的对象锁");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("线程AA：准备去获取Stu2的对象锁");
            synchronized (Stu2.class){
                System.out.println("线程AA：已经获取Stu2的对象锁");
            }
        }
    }
}

class BB extends Thread{
    @Override
    public void run() {
        synchronized (Stu2.class) {//该线程获取Stu1的对象锁
            System.out.println("线程BB：获取Stu2的对象锁");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("线程BB：准备去获取Stu1的对象锁");
            synchronized (Stu1.class){
                System.out.println("线程BB：已经获取Stu1的对象锁");
            }
        }
    }
}

　　生产者和消费者举例：

package com.hwua.myThread;

import java.util.ArrayList;
import java.util.List;

public class ProductCustomerDemo {
    public static void main(String[] args) {
        Basket basket = new Basket();
        Thread product = new Product(basket);
        Thread customer = new Customer(basket);
        product.start();
        customer.start();
    }
}
/**
 * 数据类
 * @author allen
 *
 */
class Apple{
    int id;
    
    public Apple(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Apple [id=" + id + "]";
    }
}
/**
 * 容器类
 * @author allen
 *
 */
class Basket{
    List<Apple> list = new ArrayList<Apple>();//放数据的容器
    //往里面放数据
    public synchronized void addApple(){
        for (int i = 1; i < 21; i++) {
            Apple apple = new Apple(i);
            pushApple(apple);
        }
    }
    
    //一个一个往篮子中放数据
    //放到第五个暂停，并通知消费者来消费数据
    private void pushApple(Apple apple) {
        if(list.size()==5){//达到上限，通知消费者消费
            try {
                wait();//表示当前线程挂起，等待唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        list.add(apple);//模拟放数据，并且有时间延迟
        System.out.println("生产者：生产"+apple.toString());
        notify();//唤醒当前对象被挂起的线程，第一个被挂起的线程
    }

    //消费数据
    public synchronized void consumeApple(){
        for (int i = 0; i < 20; i++) {
            getApple();
        }
    }

    private void getApple() {
        if(list.size()==0){//通知生产者去生产
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消费者：消费"+list.get(0).toString());
        list.remove(0);
        notify();
    }
}
/**
 * 生产线程
 * @author allen
 *
 */
class Product extends Thread{
    Basket b;
    public Product(Basket b) {
        this.b = b;
    }
    @Override
    public void run() {
        b.addApple();
    }
}
/**
 * 消费线程
 * @author allen
 *
 */
class Customer extends Thread{
    Basket b;
    public Customer(Basket b) {
        this.b = b;
    }
    @Override
    public void run() {
        b.consumeApple();
    }
}