JavaSE - 多线程

public class MyThread extends Thread {
    @Override
    public void run() {
        //代码就是线程在开启后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("thread is running "+i);
        }
    }
}

public class DemoThread {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread2.start();
        myThread1.start();
    }
}

从运行结果可以看出两条线程是交替运行的

关于第一种实现方法的两个小问题：

1. 为什么要重写run（）？

run（）封装线程开启后的代码

2. start（）与run（）的区别？

run（）并未真正开启线程，表示的仅仅是创建对象，然后用对象去调用方法，就是个普通调用。

start（）启动线程，由jvm调用此线程的run（）方法

2. 实现Runnable接口

定义一个类MyRunnable 实现Runnable接口

在MyRunnable中重写run（）方法

创建MyRunnable对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数

启动线程

public static void main(String[] args) {
        //创建一个参数对象
        MyRunnable myRunnable = new MyRunnable();
        //创建一个线程对象，并把参数传给线程
        //线程启动后，执行的就是参数里面的run方法
        Thread thread1 = new Thread(myRunnable);
        //开启线程
        thread1.start();
}

3.实现Callable接口

定义一个MyCallable类实现Callable接口

在MyCallable中实现call（）方法

创建MyCallable类的对象

创建Future的实现类Future task对象，把MyCallable对象作为构造方法的参数

创建Thread类对象，把Future task对象作为构造方法的参数

启动线程

public static void main(String[] args) throws ExecutionException, InterruptedException {

        //线程开启后需要执行call（）方法
        MyCallable myCallable = new MyCallable();
        //可获取线程执行完毕后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //创建一个Thread对象
        Thread thread = new Thread(futureTask);
        thread.start();
        //打印线程返回的结果
        //注意get（）方法是获取线程运行后的结果，如果线程还没结束
        System.out.println(futureTask.get());
    }

4. 三种实现方式对比

	优点	缺点
runnable & callable	扩展性强，实现该接口同时还可以继承其他的类	不能直接使用Thread类中的方法
继承Thread类	能直接使用Thread类中的方法	扩展性差，不能再继承

三、Thread方法

1.获取线程名字getName（）


private static void MyThread() {
        MyThread myThread1 = new MyThread();      
        myThread1.start();
        // 线程有默认名字，格式：Thread-0
        System.out.println(myThread1.getName());
    }

2.设置线程的名字setName（）

//第一种setName()
private static void MyThread() {
        MyThread myThread1 = new MyThread();      
        myThread1.start();
        myThread1.setName("A");
        System.out.println(myThread1.getName());
    }

//第二种有参构造设置名字
//这种方法需要区MyThread类添加有参构造
private static void MyThread() {
        MyThread myThread2 = new MyThread("B");
        myThread2.start();
        System.out.println(myThread2.getName());
    }

//MyThread类中的有参构造
public MyThread(String name) {
        super(name);
    }

3.获取当前线程对象currentThread（）

System.out.println(Thread.currentThread().getName());

4.线程休眠sleep（）

private static void threadSleep() throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        thread.sleep(2000l);
        System.out.println("after sleep");
    }

注意：如果是使用runnable接口实现的线程则不能在sleep（）时抛出异常，只能手动try catch

5.设置线程的优先级setPriority（）& getPriority（）

10：最高优先级， 1：最低优先级

线程优先级越高只能证明抢到cpu概率越高，不一定就是优先级大的线程先跑完

 private static void MyCallable() throws InterruptedException, ExecutionException {
        //线程开启后需要执行call（）方法
        MyCallable myCallable = new MyCallable();
        //可获取线程执行完毕后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //创建一个Thread对象
        Thread thread = new Thread(futureTask);
        thread.setName("A");
        thread.setPriority(1);
        thread.start();
        //打印线程返回的结果
        //注意get（）方法是获取线程运行后的结果，如果线程还没结束
//        System.out.println(futureTask.get());

        //为了验证线程优先级，再开启一条线程
        MyCallable myCallable2 = new MyCallable();
        FutureTask<String> futureTask2 = new FutureTask<>(myCallable2);
        Thread thread2 = new Thread(futureTask2);
        thread2.setName("B");
        thread2.setPriority(10);
        thread2.start();
    }

6. 守护线程setDaemon（）

当普通线程执行完毕后，守护线程也没有继续运行下去的必要

private static void daemonThread() {
        //守护线程中设置for循环次数为1000
        MyThreadDaemon myThread1 = new MyThreadDaemon("守护");
        //主线程中设置for循环次数为100
        MyThread myThread2 = new MyThread("主线程");
        myThread1.setDaemon(true);
        myThread1.start();
        myThread2.start();
    }

当主线程的100次跑完后，守护线程仅跑了105就结束了，并没有跑到1000次。

四、线程安全问题

如下是一个模拟卖票案例，Ticket类中设置一个类变量ticket表示有100张票。Demo类中创建3个线程来卖这100张票，卖完即止。

package com.unimelb.thread;

public class Ticket implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //如果有票就卖
            if (ticket > 0){
                try {
                    Thread.sleep(100L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票数-1并打印余下多少票
                ticket--;
                System.out.println(Thread.currentThread().getName() + " is selling ticket, rest: "+ticket);
            }else{
                Thread.interrupted();
            }
        }
    }
}

package com.unimelb.thread;

public class TicketDemo {
    public static void main(String[] args) {
        //只创建一个Ticket类对象，因为如果创建三个，就代表有300张票要卖。
        Ticket t1 = new Ticket();

        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t1);
        Thread thread3 = new Thread(t1);
        
        thread1.setName("A");
        thread2.setName("B");
        thread3.setName("C");
        
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

从下图的运行结果可知有两个问题：1.同一张票重复卖 2.有负数票

这种现象是由于多线程共享数据导致的，要解决则需要把共享的代码锁起来，在同一时刻只让一个线程执行

解决1：同步代码块

synchronized（对象）{

代码

}

synchronized默认打开，只要有一个线程进去执行，锁就会关闭。当线程执行完，锁才会自动打开。

优点：解决多线程数据安全问题

缺点：当线程很多时，每个线程都会去判断锁，浪费资源降低效率。

注意：锁对象必须是唯一的

针对于卖票问题的改进代码：

package com.unimelb.thread;

public class Ticket implements Runnable {
    private int ticket = 100;
    private Object object = new Object();
    @Override
    public void run() {
        synchronized (object){
            for (int i = 0; i < 100; i++) {
                if (ticket > 0){
                    try {
                        Thread.sleep(100L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + " is selling ticket, rest: "+ticket);
                }else{
                    Thread.interrupted();
                }
            }
        }
    }
}

解决2：同步方法

同步方法就是把synchronized关键字加到方法上

同步方法与同步代码块的区别：

同步代码块可以锁住制定代码，同步方法是锁住方法中所有代码
同步代码块可以指定锁对象，同步方法不能制定锁对象
同步方法的锁对象是this

解决3：同步静态方法

static synchronized 方法名（）

同步静态方法的锁对象：类名.class

融合了同步方法&同步静态方法的代码

package com.unimelb.thread;

public class Ticket implements Runnable {
    //同步静态代码块
    private static int ticket = 100;
    private Object object = new Object();
    @Override
    public void run() {
        if ("A".equals(Thread.currentThread().getName())){
            //同步静态代码块的锁对象Ticket.class
            synchronized (Ticket.class){
                for (int i = 0; i < 100; i++) {
                    if (ticket > 0){
                        try {
                            Thread.sleep(100L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticket--;
                        System.out.println(Thread.currentThread().getName() + " is selling ticket, rest: "+ticket);
                    }else{
                        Thread.interrupted();
                    }
                }
            }
        }
        if ("B".equals(Thread.currentThread().getName())){
            boolean res = synchronizedMethod();
            if (res){
                Thread.interrupted();
            }
        }
    }

    //同步方法
    private static synchronized boolean synchronizedMethod() {
        if (ticket == 0){
            return true;
        }else{
            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket--;
            System.out.println(Thread.currentThread().getName() + " is selling ticket, rest: "+ticket);
            return false;
        }
    }
}

五、lock锁

使用同步方法或同步代码块不能清晰的看到哪里上了锁，哪里释放锁

lock提供获得锁和释放锁的方法

void lock（）：获得锁

void unlock（）：释放锁

lock是接口，不能实例化，这里用他的实现类ReentrantLock来实例化

释放锁一般放在try catch finally中，以防在释放锁之前出问题

public class Ticket implements Runnable {
    private static int ticket = 100;
    private Object object = new Object();
    //创建锁对象
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        if ("A".equals(Thread.currentThread().getName())) {
//            synchronized (Ticket.class){
            //手动上锁
            try {
                lock.lock();
                for (int i = 0; i < 100; i++) {
                    if (ticket > 0) {
                        Thread.sleep(100L);
                        ticket--;
                        System.out.println(Thread.currentThread().getName() + " is selling ticket, rest: " + ticket);
                    } else {
                        Thread.interrupted();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //手动释放锁
                lock.unlock();
            }
//            }
        }       
    }

六、死锁

死锁指由于多个线程互相持有对方所需要的资源，导致线程处于等待状态，无法前往执行。

死锁通常是由于锁嵌套导致的，比如下方：

package com.unimelb.thread;

import java.util.concurrent.Callable;

public class DeadLock{
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        new Thread(() -> {
            while (true){
                synchronized (o1){
                    //第一个线程进入o1，o1锁死
                    synchronized (o2){
                        System.out.println("the first thread");
                    }
                }
            }
        }).start();

        new Thread(() -> {
            while (true){
                synchronized (o2){
                    //在第一个线程进入o1时，线程二抢到cpu并进入o2，o2锁死
                    synchronized (o1){
                        System.out.println("the second thread");
                    }
                }
            }
        }).start();
    }
}