Java多线程

public class MyThread extends Thread{
       public void run(){
           // 线程需要执行的业务操作
       }
   }
   // 启动
   MyThread mt = new MyThread();
   mt.start();

2. 实现Runnable接口，实现run方法

public class MyThread implements Runnable{
       public void run(){
           // 线程需要执行的业务操作
       }
   }
   // 启动
   MyThread mt = new Thread(new MyThread());
   mt.start();

3. 实现Callable接口，实现call方法(Callable接口是为了解决Runnable接口没有返回值缺陷而产生的。实现Callable接口可以得到线程执行完毕后的返回值。)

public class MyThread implements Callable<String>{
       public String call() throws Exception {
           // 线程需要执行的业务操作
           return null;
       }
   }
   // 启动
   FutureTask<String> ft = new FutureTask(new MyThread());
   MyThread mt = new Thread(ft);
   mt.start();

注：线程的启动，是调用start()方法。线程启动后，就会执行线程类中的run()/call()方法，完成线程业务的处理。

那么，能不能直接调用run()方法呢？

调用start()和调用run()方法，具有不同的含义：

调用start方法，会在主线程基础上，开启新的子线程。

调用run方法，只是普通方法调用。不会在主线程的基础上，开启新的子线程。

4. 线程池创建

问题：当我们的程序，需要大量通过new Thread()方法创建执行时间短的线程，会消耗很多的系统资源导致系统的响应速度变慢。

解决办法：线程池(其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源)

使用线程池的步骤：

1. 创建线程池对象

2. 创建Runnable/Callable 接口子类对象

3. 提交 Runnable/Callable 接口子类对象

4. 关闭线程池

// 创建一个无限大的线程池，适用于负载较轻的场景
   ExecutorService service = Executors.newCachedThreadPool();
   
   // 创建一个固定大小的线程池
   ExecutorService service = Executors.newFixedThreadPool(5);
   // 创建一个单线程的线程池
   ExecutorService service = Executors.newSingleThreadExecutor();
   
   
   service.excute(Runnable);
   Future<V> result = service.submit(Callable<V>);
   V value = result.get();

注意：创建一个线程数为n的线程池后，可以提交超出线程个数n的任务，但是只能同时执行的任务个数为n，等有线程空闲后，才会执行后续的任务。

// 创建一个固定大小的线程池，指定演示，使用于执行延时或周期性任务
   ScheduledExecutorService service = Executors.newScheduledThread(5);
   // 延迟1秒后每3秒执行一次
   service3.scheduleAtFixedRate(new Task("AtFixedRate"),1,3,TimeUnit.SECONDS);

线程的优先级

线程的优先级是指，当两个或两个以上的线程同时处于就绪状态时，优先级高的线程会优先得到执行。

// 关于优先级的方法：
   final void setPriority(int newp) 修改线程的当前优先级
   final int getPriority()   返回线程的优先级

线程的同步

程序在执行过程中，可能会发生两个或多个线程同时访问一个资源的情况。

出现这样的情况后，可能会引发一些安全性的问题。出现安全性的问题怎么解决呢？可以设置线程的同步。

什么是线程同步呢？线程同步是指，当两个或两个以上的线程同时访问同一个资源时，为了确保数据的安全，只允许同一时间点，同一个共享资源

只被一个线程进行访问。线程同步也称为线程安全。

线程同步的结果：

1. 数据安全

2. 效率低下

那怎么实现线程同步？使用同步关键字synchronized来进行标识，实现的方式有两种，同步方法和同步块

class Account{
    /** 账户余额 */
    private volatile int money = 31000;
    // 同步方法
    public synchronized boolean getMoney(int nums){
            if(nums < money){
                this.money -= nums;
                System.out.println("取钱成功,取款金额" + nums + ",余额" + this.money);
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return true;
            }else {
                System.out.println("取款失败，余额不足");
                return false;
            }
    }
    
    // 同步块
    public  boolean getMoney1(int nums){
            synchronized (this){
                if(nums < money){
                    this.money -= nums;
                    System.out.println("取钱成功,取款金额" + nums + ",余额" + this.money);
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return true;
                }else {
                    System.out.println("取款失败，余额不足");
                    return false;
                }
            }
    }
}

class Get implements Runnable{
    private Account account;
    private int nums;
    public Get(Account account,int nums){
        this.account = account;
        this.nums = nums;
    }

    @Override
    public void run() {
        while (account.getMoney(nums)){
        }
    }
}

死锁

死锁是指在多线程情况下，多个线程同步竞争相互依赖的资源，从而造成多线程无法继续执行的情况。死锁很少发生，但一旦发生就很难调试。

举例子：当我们在乡间小路驾车行驶时，如果遇到对向来车，然后自己和对方互不相让，我们此时就是在同步竞争相互依赖的资源。

public class Die {
    public static void main(String[] args) {
        Obj a = new Obj();
        Obj b = new Obj();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (a){
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    b.test();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (b){
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    a.test();
                }
            }
        }).start();
    }
}

class Obj{
    public synchronized void test(){
        System.out.println("方法调用");
    }
}

wait-notify机制及生产者消费者模型

多线程机制，使得我们可以将需要完成的任务分为多个逻辑单元，并交给不同的线程完成。在线程同步的情况下，当一个线程在访问一个共享资源时，别的线程只能针对该资源进行等待访问。并且为避免死锁的情况出现，应当一个线程在访问完毕共享资源时，通知别的线程可以对共享资源进行访问。

问题来了，如何通知呢？

Java提供了wait－notify机制，完成线程间的通信。

1. Java使用wait()、notify()和notifyAll()方法，完成线程间的通信。这些方法是作为 Object 类中的 final 方法实现的。这三个方法仅在 synchronized 方法中才能被调用。

2. wait()方法告知被调用的线程退出监视器并进入等待状态，直到其他线程进入相同的监视器并调用 notify( ) 方法。

3. notify( ) 方法通知同一对象上第一个调用 wait( )线程。

4. notifyAll() 方法通知调用 wait() 的所有线程，具有最高优先级的线程将先运行。

我们可以通过Java代码实现生产者消费者模型辅助理解wait－notify机制

public class WaitNotify {
    public static void main(String[] args) {
        Factory factory = new Factory();
        new Thread(new Producer(factory)).start();
        new Thread(new Consumer(factory)).start();
    }
}

class Producer implements Runnable{
    private Factory factory;
    public Producer(Factory factory){
        this.factory = factory;
    }
    @Override
    public void run() {
        for(int i = 1;i <= 50;i++){
            this.factory.add(i);
        }
    }
}
class Consumer implements Runnable{
    private Factory factory;
    public Consumer(Factory factory){
        this.factory = factory;
    }
    @Override
    public void run() {
        for(int i = 1;i <=50;i++){
            this.factory.del();
        }
    }
}
// 供货工厂
class Factory{
    // 保存货物
    int[] foods = new int[10];
    // 计数器 记录当前工厂商品数量
    int count = 0;
    // 生产
    public synchronized void add(int food){
        // 判断商品库存是否达到极限
        if(foods.length == count){
            try {
                // 生产者不再生产
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if(count < foods.length){
            // 生产
            foods[count] = food;
            count++;
            System.out.println("生产者生产第" + food + "只炸鸡");
            // 叫消费来吃鸡
            this.notifyAll();
        }
    }
    // 消费
    public synchronized void del(){
        if(count == 0){
            try {
                // 通知消费者休息
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        if(count != 0){
            int food = foods[--count];
            System.out.println("消费者吃了第" + food + "只炸鸡");
            this.notifyAll();
        }
    }
}

注意：wait和sleep的区别。wait()方法和sleep方法，都能让线程暂时停止运行。但是它们使用的方式和时机是不同的。

1. sleep方法在线程类Thread中定义，wait方法在Object中定义。

2. wait方法只能放在同步方法或同步块中，表示当前线程对资源进行等待。sleep方法可以放在任何位置，表示当前线程休眠。

3. wait方法要释放对象锁，sleep方法不会释放对象锁。

4. wait方法使用后，线程需要notify唤醒后才能继续执行。而sleep在休眠结束后，线程自动继续执行。

加锁的其他方式Lock接口

- Lock接口是java解决线程安全的另一种形式。

相对于synchronized，有以下特点：

1. Lock是一个接口，而synchronized是Java内置的语言实现；

2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unlock（）去释放锁，则很可能造成死锁现象，因此使用lock时需要在finally块中释放锁；

3. Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4. 通过Lock可以知道有没有成功获取锁，而synchronized无法办到；

5. lock可以提高多个线程进行读操作的效率

public class LockTest {
    public static void main(String[] args) {
        LockObj obj = new LockObj();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.speak();
            }
        },"第一线程").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                obj.speak();
            }
        },"第二线程").start();
    }
}

class LockObj {
    private Lock lock = new ReentrantLock();
    public void speak() {
        // 通过Lock接口的实现类对象 获取锁
        if(lock.tryLock()){
            try {
                for (int i = 0; i < 50; i++) {
//                Thread.currentThread().getName()  可获取当前线程名称
                    System.out.println(Thread.currentThread().getName() + "speak" + i);
                    Thread.sleep(30);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 释放锁
                lock.unlock();
            }
        }else {
            System.out.println("获取锁失败");
        }
    }
}

// lock()方法可以获取锁，但无返回值
// trylock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true
// unlock()方法可以释放锁

读写Lock

当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

采用synchronized关键字来实现同步的话，就会导致一个问题：如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过读写锁可以办到。

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程可以同时进行读操作。申请写操作的线程只能等待。如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

public class RWLock {

    public static void main(String[] args) {
        RW rw = new RW();
        new Thread(new Runnable() {
            @Override
            public void run() {
                rw.write();
            }
        },"刘六").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                rw.read();
            }
        },"张三").start();

    }
}

class RW{
    // 创建读写Lock对象
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 读
    public void read(){
        // 获取读锁
        rwLock.readLock().lock();
        try {
            for(int i = 0;i < 20;i++){
                System.out.println(Thread.currentThread().getName() + "读" + i);
                Thread.sleep(1);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
    }
    // 写
    public void write(){
        rwLock.writeLock().lock();
        try {
            for(int i = 0;i < 20;i++) {
                System.out.println(Thread.currentThread().getName() + "写" + i);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }
}