java高级编程复习--01--多线程

进程与线程：

　　进程就是在操作系统中，运行中的程序，每个程序就是一个单独的进程；在多核多线程处理器的时代，在进程运行中，通过多线程技术，为系统减少上下文消耗，提高并发量；

JAVA中实现多线程的方式：

1，Thread类实现多线程：通过继承Tread类，重写run方法来实现多线程操作；具体代码如下

package com.zehui.thread;

/**
 * @Classname ThreadTest
 * @Description TODO
 * @Date 2020/3/4 3:19
 * @Created by Nikla
 */
public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread("my1");
        MyThread myThread2 = new MyThread("my2");
        myThread1.start();  ///启动线程1
        myThread2.start();  ///启动线程2
        //错误，不能重复启动一个线程，否则会抛出IllegalThreadStateException
        /*for (int i = 0; i < 10; i++) {
            if (!myThread1.isAlive()) {
                myThread1.start();
            }
            if (!myThread2.isAlive()) {
                myThread2.start();
            }
        }*/

    }
}

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(this.getName() + "running");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

优点：简单方便，直接new该类对象，执行start方法就可以启动多线程

缺点：单继承局限，已继承Thread后不能继承其他类；

2，Runnable接口实现多线程：多线程执行类通过实现Runnable接口，重写run方法即可

package com.zehui.thread;

/**
 * @Classname RunnableTest
 * @Description TODO
 * @Date 2020/3/4 3:33
 * @Created by Nikla
 */
public class RunnableTest {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable("haha");
        Thread mythread = new Thread(runnable);
        mythread.start();
 }
}

class MyRunnable implements  Runnable{

    private  String name;

    public MyRunnable(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void run() {
        System.out.println(this.getName()+" runnable");
    }
}

3，有点：取消继承Thread类的依赖（单继承的局限）

Thread与Runnable的关系：

　　在Thread启动多线程的时候，调用的是start方法，最后执行的是run方法；通过Thread类的构造方法，传入Runnable接口的对象是，那么接口对象被Thread对象的target属性保存，执行的strat方法的时候调用用run方法，而这个run方法去调用runnable接口子类被覆写过的run方法；

                             

　　多线程开发的本质实质上是在与多个线程可以进行同一资源的抢占，Thread主要来描述线程，Runnable来描述资源

                              

 　

 4，Callable接口

　　Runnable接口实现多线程，没有不能返回线程执行的结果，而Callable接口则可以返回现车执行的结果；

　　代码如下：

　　

package com.zehui.thread;

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

/**
 * @Classname CallableTest
 * @Description TODO
 * @Date 2020/3/4 3:37
 * @Created by Nikla
 */
public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();   //新建接口子类对象
        //FutureTask泛型类型为Callable接口的泛型类型，也即接口子类对象返回值类型
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        new Thread(futureTask).start();
        //获取线程执行结果
        System.out.println(futureTask.get());
    }
}
class MyCallable implements Callable<String>{

    @Override
    public String call() {
        for (int i = 0; i < 10 ; i++) {
            int x= i+1;
            System.out.println("MyCallable 打印出 x="+ x);
        }
        return "MyCallable 执行完毕";
    }
}

　  类关系图如下：

对线程常用方法：
线程命名和取得

多线程深入话题：
优雅的停止线程：正式编写代码中，可以使用Threa.sleep(【毫秒值】);来停止线程；
后台守护线程：
守护线程：程序中，当进程内所有非守护线程执行结束后面，无论守护线程在任何状态，都会停止执行；jvm中，垃圾回收gc就是守护线程；
设置守护线程：thread.setDaemon(true);
volatile：该关键字定义的变量，在多线程环境中，线程直接操作该变量；若没有添加该关键的变量，多线程环境中，线程内操作该变量，是操作做线程内该变量的副本，操作完成后再同步到该变量中；

多线程综合案例：
数字加减：
生产电脑：
竞争抢答：