【JAVA基础】多线程的实现及锁和死锁的问题

线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：

调用了 Runtime 类的 exit 方法，并且安全管理器允许退出操作发生。
非守护线程的所有线程都已停止运行，无论是通过从对 run 方法的调用中返回，还是通过抛出一个传播到 run 方法之外的异常。

不会立即执行，它会去抢执行权，抢到才能立即执行。

代码实现

• 方式1：Thread

package com.gaofeng.day22;
public class MyThread extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "hello world");
        }
    }
}

package com.gaofeng.day22;
public class demo01 {
    public static void main(String[] args) {

        /**
         * 多线程的第一种启动方式
         */
        MyThread t1 = new MyThread();
        t1.setName("线程1");
        t1.start(); // 开启线程
        MyThread t2= new MyThread();
        t2.setName("线程2");
        t2.start();

    }
}

• 方式2：Runnable

package com.gaofeng.day22;
public class MyRun implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "hello world");
        }
    }
}

package com.gaofeng.day22;
public class demo02 {
    public static void main(String[] args) {

        MyRun myRun = new MyRun();

        Thread t1 = new Thread(myRun);
        t1.setName("线程1");
        t1.start();
        Thread t2 = new Thread(myRun);
        t2.setName("线程2");
        t2.start();
    }
}

• 方式3：Callable

package com.gaofeng.day22;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

package com.gaofeng.day22;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class demo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<>(mc);

        Thread thread = new Thread(ft);
        thread.start();

        Integer result = ft.get();
        System.out.println(result);
    }
}

• 总结
  方式3有返回值，前面两种没有返回值。

同步锁的实现

需求：三个窗口，同时卖100张票的实现

package com.gaofeng.day22.a07ThreadDemo;
public class MyThread  extends Thread{
    static  int ticket = 0;

    //锁对象一定要是唯一的，共享的要加上static
   static Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(ticket < 100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+ "正在卖第 "+ticket +" 张票");
                }else{
                    break;
                }
            }
        }
    }
}

• 测试类

package com.gaofeng.day22.a07ThreadDemo;


public class ThreadDemo {
    public static void main(String[] args) {

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

         t1.start();
         t2.start();
         t3.start();
    }
}

实现效果

• 第二种实现方法
  

public class MyRunnable implements Runnable{
    int ticket = 0;
    
    @Override
    public void run() {
         while (true){
             if (method()) break;
         }
    }

    private synchronized boolean method() {
        if (ticket == 100) {
            return true;
        } else {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "正在卖第 " + ticket + " 张票");
        }
        return false;
    }
}

• 测试类

public class ThreadDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);

        t1.setName("窗口1");
        t1.setName("窗口2");
        t1.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

• 手动上锁

public class MyThread extends Thread{
    static int ticket = 0;
    // 共享一个锁
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticket == 100) {
                    // lock.unlock();
                    break;
                } else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName() + "正在卖第 " + ticket + " 张票");
                }
            } catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

    }
}

• 测试类

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

死锁

一般情况下，嵌套的锁会造成死锁,所以要避免嵌套锁

public class MyThread extends Thread{
    static Object objA = new Object();
    static Object objB = new Object();
    @Override
    public void run() {
        while (true){
            if("线程A".equals(getName())){
                synchronized (objA){
                    System.out.println("线程A拿到了A锁");
                    synchronized (objB){
                        System.out.println("线程A拿到了B锁");
                    }
                }
            }else if("线程B".equals(getName())){
                if("线程B".equals(getName())){
                    synchronized (objB){
                        System.out.println("线程B拿到了A锁");
                        synchronized (objA){
                            System.out.println("线程B拿到了A锁");
                        }
                    }
                }
            }
        }
    }
}