Thread

title: 【学习之路】多线程学习
draft: true
tags:

• 学习之路
• 多线程
  categories:
• JavaSE
• 多线程
  cover: ‘https://cdn.jsdelivr.net/gh/CodeZixuan/Blog_Images/Thread/bg.jpg‘
  description: 多线程学习，如何创建多线程，锁的概念等
  abbrlink: 26002bce
  date: 2021-03-27 09:06:50

什么是多线程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

在Java中创建多线程

方法一

1. 创建一类继承Thread类
2. 重写Thread类的run()方法
3. 创建Thread类的子类对象
4. 通过此对象调用start()方法

public class ThreadTest extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程");
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        // 创建Thread类的子类对象
        ThreadTest test = new ThreadTest();
        // 通过此对象调用父类的start()方法：start方法会启动当前线程并且调用当前线程的run()方法
        test.start();
        // 这下面的操作任然是在main方法中执行的
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习英语");
        }
    }
}

不能通过调用run()方法开启多线程

不能同时用一个对象调用多次start()方法不然会抛出异常，此时需要new多个对象实列来调用start方法

方法二

创建Thread类的匿名子类

public class TestMain {
    public static void main(String[] args) {
       new Thread(){
           @Override
           public void run() {
               System.out.println("我在学习多线程");
           }
       }.start();
    }
}

方法三

1. 实现Runnable
2. 实现Runnable接口中的抽象方法run()
3. 创建实现类的对象
4. 将此对象作为参数传入到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

public class ThreadTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程");
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        Thread thread = new Thread(test);
        thread.start();
    }
}

方式四

1. 实现Callable接口

2. 重写call()方法

3. 创建实现类对象

4. 创建FutureTask的实现类

5. 创建Thread实列将FutureTask实列传入

6. 调用Thread的start()

public class ThreadTest2 implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++){
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class TestMain {
    public static void main(String[] args) {
        ThreadTest2 ts2 = new ThreadTest2();
        FutureTask futureTask = new FutureTask(ts2);
        new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println(sum);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

方式五——JDK5.0新特性

1. 使用Executors线程池创建线程返回ExecutorService
2. 写一个类实现Runnable或Callable
3. 通过返回的ExecutorService调用execute()（适用于Runnable）或submit()（适用于Callable）将实现Runnable或Callable的实列传入到execute() 或 submit()中

public class ThreadPool implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++){
            System.out.println(i);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new ThreadPool());
    }
}

Thread中的常用方法

1. void start()：启动线程，并执行对象的run()方法
2. run()：线程在被调度时执行的操作
3. String getName()：返回线程的名称
4. void setName()：设置该线程的名称
5. static Thread currentThread()：返回当前线程，在Thread子类中就是this，通常用于主线程和Runnable实现类
6. yield()：释放当前线程执行权
7. join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，知道线程b执行完成以后，线程a才结束阻塞状态
8. sleep(long millis)：让当前线程睡眠，单位为毫秒值
9. isAlive()：判断当前线程是否存活

线程的优先级

1. MAX_PRIORITY=10
2. MIN_PRIORITY=1
3. NORM_PRIORITY=5

1. getPriority()：获取线程的优先级
2. setPriority(int p)：设置线程的优先级

线程优先级高并不代表一定会执行这个线程，只是从概率来说会执行高优先级的线程可能性更大

线程安全问题

1. 列：创建三个窗口卖票，总票数为100张。

public class ThreadTest implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
       while (true){
           if (ticket > 0){
               System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
               ticket--;
           }else {
               break;
           }
       }
    }
}

public class TestMain {
    public static void main(String[] args) {
        ThreadTest test = new ThreadTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
    }
}

从这里我们可以看出有可能同时有两个线程会操作同一张票而导致错票问题

解决方式一：同步代码块

使用synchronized的方式来解决线程安全问题

synchronized(同步监视器){
    // 需要被同步的代码
}

同步监视器俗称：锁

• 锁可以是任何一个类的对象，都可以充当锁

• 多个线程必须要共同用同一把锁

方式一：new一个唯一对象

public class ThreadTest implements Runnable{
    private int ticket = 100;
    private Object obj = new Object();
    @Override
    public void run() {
       while (true){
           synchronized (obj) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
                   ticket--;
               } else {
                   break;
               }
           }
       }
    }
}

如果使用这个方式需要考虑是否是唯一对象，如果不是需要加上static

方式二：使用this关键字

public class ThreadTest implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
       while (true){
           synchronized (this) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
                   ticket--;
               } else {
                   break;
               }
           }
       }
    }
}

如果使用这个方式需要考虑this是否是唯一对象

方式三：使用当前类

public class ThreadTest implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
       while (true){
           synchronized (ThreadTest.class) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
                   ticket--;
               } else {
                   break;
               }
           }
       }
    }
}

解决方式二：同步方法

public class ThreadTest implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            show();
            if (ticket == 0) {
                break;
            }
        }
    }
    public synchronized void show() {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
            ticket--;
        }
    }
}

使用同步方法的时候同步监视器的对象就是：this

如果使用继承Thread的方式需要把方法改为static，当前同步监视器的对象就是当前类

解决方式三：Lock锁——JDK 5.0新增

public class ThreadTest implements Runnable {
    private int ticket = 100;
    // 实列化ReentrantLock
    private ReentrantLock lock =  new ReentrantLock();
    @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();
            }
        }
    }
}

死锁问题

死锁概述：不通的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己所需要的同步资源，就会形成死锁。出现死锁后不会出现异常，也不会提示，只是所有线程都会处于阻塞状态，无法继续。

死锁是开发中是需要避免的操作

解决方法

1. 使用专门的算法
2. 尽量减少同步资源的定义
3. 尽量避免嵌套同步