D1 多线程总结

前言

忙忙碌碌各种花里胡哨的事情，总算把尚硅谷的Java基础学完了。
在步入数据库之前，先进行一个初步总结。

---

1. 线程的状态

线程的状态可以分为：新建、就绪、运行、阻塞、死亡

2.线程的创建

线程有四种创建方式，分别是继承Thread类，实现Runnable接口，实现Callable接口和使用线程池。
虽然创建方式有4种，但常用的方法就这些：

• start()：一个线程启动后不可再调用start()
• getName(),
• setName()
• currentThread()
• yield()：暂停该线程，让步给相同或更高优先级的线程，只有更低优先级线程时此方法无效
• join()：运行该线程至结束，其它进程阻塞，无视优先级
• sleep(n)：该线程放弃CPU n毫秒，时间到后重新排队
• isalive()
• getPriority() & setPriority()：优先级从低到高1-10，默认为5，优先级只代表获得调度的概率，并不是严格的先后顺序

---

2.1 继承Thread类

继承Thread类并重写run方法，然后实例化并调用start()方法即可

class MyThread extends Thread{
    // 重写run以需要进行的操作
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(getName() + i + "***" + getPriority());
            }
//            if (i % 20 == 0){
//                Thread.yield();
//            }
        }
    }
}
public class ThreadCreat {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        // 启动线程，调用run；直接调用run相当于调用方法，并没有新建线程
        Thread.currentThread().setName("主线程");
        myThread.setName("线程一");
        myThread.setPriority(Thread.MAX_PRIORITY);
        myThread.start();
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + i + "*main()*");
            }
            if (i % 10 == 0){
                myThread.join();
            }
        }
    }
}

---

2.2 实现Runnable接口

实现Runnable接口，实例化，再将对象传入Thread的构造器中，获得Thread类的实例化对象。

	MiThread miThread = new MiThread();
    Thread t1 = new Thread(miThread);
    t1.start();

此方法的优点：

• 避免了单继承的局限性
• 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

---

2.3 实现Callable接口

实现Runnable接口，实例化，再将对象传入FutureTask的构造器中，获得FutureTask实例化对象。

	MyThread3 myThread3 = new MyThread3();
	FutureTask futureTask = new FutureTask(myThread3);
	new Thread(futureTask).start();

此方法的优点：

• 可以有返回值(FutureTask对象.get())
• 可以抛出异常
• 支持泛型返回

---

2.4 使用线程池

提前创建好多个线程放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
学的很浅，后续继续补充。

   ExecutorService service = Executors.newFixedThreadPool(10);
// 	变为线程池类才可以设置各种属性
   ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;

// 	service1.setCorePoolSize();
//	执行指定的线程操作，需要提供Runnable或Callable实现类对象
   service.execute(new MyThread4()); // 适合Runnable
   service.execute(new MyThread5()); // 适合Runnable
//	service.submit(); // 适合Callable
//	关闭连接池
   service.shutdown();

此方法的优点：

• 提高响应速度（减少了创建新线程的时间）
• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 便于线程管理

---

3. 线程的安全

安全问题出现的原因：

• 多个线程执行的不确定性引起执行结果的不稳定
• 多个线程对数据的共享，会造成操作的不完整

解决安全问题有三种方法，分别是同步代码块，同步方法和Lock锁，都要用到锁机制：

锁，即同步监视器，使用同一把锁的线程才能同步，不同锁的线程不同步。一般静态方法使用类名.class，非静态方法使用this

---

同步代码块：

synchronized(锁){
	共享数据
}

同步方法：锁已默认的给出

private synchronized void method(){}

Lock锁：需要先实例化ReentrantLock

	private ReentrantLock lock = new ReentrantLock();
	lock.lock();
	try{}
	finally{
 		lock.unlock()
	}

三者的比较：

• synchronized机制在执行完同步代码后自动释放同步监视器
• Lock需要手动启动同步和结束同步
• 优先使用Lock，其次同步代码块，再次同步方法

---

4. 线程的通信

主要是wait()，notify()，notifyAll()这三种方法。
这三个方法只有在同步方法或同步代码块中才能使用，必须由锁调用。

• wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒此进程，唤醒后等待重新获得对监视器的所有权后才能继续执行。
• notify()：唤醒正在排队等待同步资源的线程中优先级最高者
• notifyAll()：唤醒正在排队等待资源的所有线程

---

5. 线程安全的懒汉式

class Bank{
    private Bank(){}
    private static Bank instance = null;
    private static Bank getInstance(){
        // 1.效率低，后续线程都需要等待进入同步代码块
//        synchronized (ThreadSafe.Bank.class) {
//            if (instance == null){
//                instance = new ThreadSafe.Bank();
//            }
//        }
        // 2.后续不用进入同步代码块，效率高点
        if (instance == null){
            synchronized(Bank.class){
                if (instance == null){
                    instance = new Bank();
                }
            }
        }

        return instance;
    }
}

---

6. 生产者消费者模型

class Clerk{
    private int product = 0;
    // 生产产品
    public synchronized void getProduct() {
        if (product < 20){
            product++;
            System.out.println(Thread.currentThread().getName() + "开始生产第" + product + "个产品。");
            notify();
        }else{
            // 等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // 消费产品
    public synchronized void useProduct() {
        if (product > 0){
            System.out.println(Thread.currentThread().getName() + "开始消费第" + product + "个产品。");
            product--;
            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.getProduct();
        }
    }
}

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(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.useProduct();
        }
    }
}


public class ProductModel {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        Producer p2 = new Producer(clerk);
        p1.setName("生产者1");
        p1.setName("生产者2");

        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);
        c1.setName("消费者1");
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}