Java学习笔记------Twenty-two（多线程）

一，多线程
1.线程：在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。
2.多线程的意义：多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。
3.实现多线程的方式1:继承Thread类

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread th1 = new MyThread("大黄蜂");
        MyThread th2 = new MyThread("擎天柱");
        MyThread th3= new MyThread("威震天");
        th1.setDaemon(true);
        th2.setDaemon(true);
        th3.setDaemon(true);
        th1.start();
        th2.start();  
        th3.start();

 class MyThread extends Thread{
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
         //   MyThread.yield();
            System.out.println(this.getName()+" "+i);
        }
    }
}

A:Thread类的基本获取和设置方法
public final String getName()//获取线程名称
public final void setName(String name)//设置线程名称
public static Thread currentThread()//获取当前执行的线程
public static Thread currentThread()返回对当前正在执行的线程对象的引用。
B:设置和获取线程优先级
public final int getPriority() //获取线程的优先级（线程的默认优先级是5）
public final void setPriority(int newPriority)//设置线程的优先级
C:线程休眠: public static void sleep(long millis) 线程休眠
D:加入线程: public final void join()
意思就是: 等待该线程执行完毕了以后,其他线程才能再次执行
注意事项: 在线程启动之后,在调用方法
E:礼让线程: public static void yield(): 暂停当前正在执行的线程对象，并执行其他线程。

• 这个礼让是要暂停当前正在执行的线程,这个暂停的时间是相当短的,如果在这个线程暂停完毕以后,其他的线程还没有
• 抢占到CPU的执行权,那么这个时候这个线程应该再次和其他线程抢占CPU的执行权. 所以在实际测试中效果并不是很明显。
  F:守护线程: public final void setDaemon(boolean on):
  将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
  该方法必须在启动线程前调用。 在实际中因为运行延迟，标记为守护线程的线程并不会在程序运行后就立即死掉，还会有短暂运行的记录，实际效果并不是很理想
  G:中断线程
  public final void stop(): 停止线程的运行
  public void interrupt(): 中断线程(这个翻译不太好),查看API可得当线程调用wait(),sleep(long time)方法的时候处于阻塞状态,可以通过这个方法清除阻塞
  4.多线程程序实现的方式2：实现Runnable接口 这种方式扩展性强 实现一个接口 还可以再去继承其他类。
  案例演示：

public class Test2 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable,"路飞");
        thread.start();
        Thread thread1 = new Thread(myRunnable, "索隆");
        thread1.start();
    }
}

 class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

实现接口方式的好处：可以避免由于Java单继承带来的局限性。
5.多线程程序实现的方式3：实现 Callable 接口
A:相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
B:执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。 FutureTask 是 Future 接口的实现类
C:实现步骤
1.创建一个类实现Callable 接口
2.创建一个FutureTask类将Callable接口的子类对象作为参数传进去
3.创建Thread类,将FutureTask对象作为参数传进去
4.开启线程
案例演示：

public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable(100);
        FutureTask<Integer> integerFutureTask = new FutureTask<>(myCallable);
        Thread th = new Thread(integerFutureTask, "Lucy");
        th.start();
        Integer integer = integerFutureTask.get();
        System.out.println(integer);

        MyCallable myCallable1 = new MyCallable(1000);
        FutureTask<Integer> integerFutureTask1 = new FutureTask<>(myCallable1);
        Thread th1 = new Thread(integerFutureTask1, "Aersha");
        th1.start();
        Integer integer1 = integerFutureTask1.get();
        System.out.println(integer1);
    }
}

 class MyCallable implements Callable<Integer> {
    int num;
    public MyCallable(int num) {
        this.num=num;
    }

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 1; i <= sum; i++) {
            sum+=i;
        }
        return sum;
    }
}

6.死锁
A:死锁问题概述
如果出现了同步嵌套，就容易产生死锁问题
是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
同步代码块的嵌套案例
死锁: 两个或者两个以上的线程,在抢占CPU的执行权的时候,都处于等待状态
案例演示：

public class Test {
    public static void main(String[] args) {
        MyThread th1 = new MyThread(true);
        MyThread th2 = new MyThread(false);
        th1.start();
        th2.start();
    }
}

 interface MyInterface {
    public static final Object obj=new Object();
    public static final Object obj1=new Object();
}

class MyThread extends Thread {
    boolean b;
    public MyThread(boolean b) {
        this.b=b;
    }
    @Override
    public void run() {
        if(b) {
            synchronized (MyInterface.obj) {
                System.out.println("true  obj进来了");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (MyInterface.obj1) {
                    System.out.println("true  obj1进来了");
                }
            }
        } else{
            synchronized (MyInterface.obj1){
                System.out.println("false  obj1进来了");

            synchronized (MyInterface.obj){
                System.out.println("false   obj进来了");
            }
            }
        }
    }
}