Java-多线程

一.进程、线程、协程：

 1.进程：

         进程是资源分配的基本单位，进程是程序执行时的一个实例。比如要运行一个游戏，打开一个软件，就是一个进程。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

　　  进程拥有代码和打开的文件资源、数据资源、独立的内存空间。

  2.线程：

　　  线程从属于进程，是一条执行路径，是程序执行时的最小单元，是CPU调度和分派的基本单位。一个进程可以由多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。

　　  比如：一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

• 对于单核CPU而言：多线程就是一个CPU在来回的切换，在交替执行。
• 对于多核CPU而言：多线程就是同时有多条执行路径在同时(并行)执行，每个核执行一个线程，多个核就有可能是一块同时执行的。

   3.进程与线程的区别关系：

　　　每个进程拥有自己的一整套变量，而线程则是共享数据。

　　　对操作系统来说，线程是最小的执行单元，进程是最小的资源管理单元。

　　    无论进程还是线程，都是由操作系统所管理的。

　　    Java中线程具有五种状态：初始化、可运行、运行中、阻塞、销毁。JVM需要通过操作系统内核中的TCB（Thread Control Block）模块来改变线程的状态，这一过程需要耗费一定的CPU资源。

            

 

 

 

 

  4.协程：

　　　协程是比线程更加轻量级的存在。一个线程可以拥有多个协程。协程不被操作系统内核所管理，它完全由程序所控制。协程的开销远小于线程的开销。

             

 

二.线程的构造方法

1.在一个单独的线程中执行一个任务的过程：

　（1）将任务代码移到实现了Runnable接口的类的run方法中：（2）创建一个类对象：（3）由Runnable创建一个Thread对象：（4）启动线程：

　　public interface Runnable{

　　　　void run();

　　}

　　或者如下实现一个类：

　　class MyRunnable implements Runnable{

　　　　public void run(){

　　　　　　task code

　　　　}

　　}

　（2）创建一个类对象：

　　Runnable r = new MyRunnable();

　（3）由Runnable创建一个Thread对象：

　　Thread t = new Thread(r);

　（4）启动线程：

　　t.start();

 2.常用方法

 

三.为什么要使用多线程：

     提高程序效率。

　  创建线程为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。

 

四.Java多线程的几种方法

1.extends Thread——继承Thread类

（1）定义一个类继承Thread。

（2）重写run方法。Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

（3）创建子类对象，就是创建线程对象。

（4）调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

注意：线程对象调用 run方法和调用start方法区别？
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

public static void main(String[] args) {

        //创建自定义线程对象

        MyThread mt = new MyThread("新的线程！");

        //开启新线程

        mt.start();

        //在主方法中执行for循环

        for (int i = 0; i < 10; i++) {

        System.out.println("main线程！"+i);

        }

    }

}

//自定义线程类

public class MyThread extends Thread {

    //定义指定线程名称的构造方法

    public MyThread(String name) {

        //调用父类的String参数的构造方法，指定线程的名称

        super(name);

    }

    /**

     * 重写run方法，完成该线程执行的逻辑

     */

    @Override

    public void run() {

        for (int i = 0; i < 10; i++) {

            System.out.println(getName()+"：正在执行！"+i);

        }

    }

}     
class ThreadDemo {

    public static void main(String[] args) {

        //创建两个线程任务

        MyThread d = new MyThread();

        MyThread d2 = new MyThread();

        d.run();//没有开启新线程, 在主线程调用run方法

        d2.start();//开启一个新线程，新线程调用run方法

    }

}    

 

2.implements Runnable——实现Runnable接口

Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

（1）定义类实现Runnable接口。

（2）覆盖接口中的run方法。

（3）创建Thread类的对象

（5）将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

（6）调用Thread类的start方法开启线程。

public class Demo02 {

    public static void main(String[] args) {

        //创建线程执行目标类对象

        Runnable runn = new MyRunnable();

        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数

        Thread thread = new Thread(runn);

        Thread thread2 = new Thread(runn);

        //开启线程
    
        thread.start();

        thread2.start();

        for (int i = 0; i < 10; i++) {

            System.out.println("main线程：正在执行！"+i);

        }

    }

}

//自定义线程执行任务类

public class MyRunnable implements Runnable{

    //定义线程要执行的run方法逻辑

    @Override

    public void run() {

         for (int i = 0; i < 10; i++) {

            System.out.println("我的线程：正在执行！"+i);

        }

    }

}        

A.继承Thread类和实现Runnable接口的区别：

实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。

创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

B.实现Runnable的好处

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

3.Threadpool——线程池实现Callable

4.三种方式比较：

（1）Thread: 继承方式, 不建议使用, 因为Java是单继承的，继承了Thread就没办法继承其它类了，不够灵活
（2）Runnable: 实现接口，比Thread类更加灵活，没有单继承的限制
（3）Callable: Thread和Runnable都是重写的run()方法并且没有返回值，Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行
　　当线程不需要返回值时使用Runnable，需要返回值时就使用Callable，一般情况下不直接把线程体代码放到Thread类中，一般通过Thread类来启动线程
　　Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现

五.线程池的使用

 1.什么是线程池：

　　线程池是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

 

 

 2.为什么要用线程池：

　　除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。

　　线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

3. 使用线程池方式

　　通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

（1）Runnable接口

　　　　Executors：线程池创建工厂类

　　　　public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

　　　　ExecutorsService：线程池类

　　　　Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

　　　　Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 

　　　　使用线程池中线程对象的步骤：

　　　　　　a.创建线程池对象

　　　　　　b.创建Runnable接口子类对象

　　　　　　c. 提交Runnable接口子类对象

　　　　　　d.关闭线程池

public class ThreadPoolDemo {

    public static void main(String[] args) {

        //创建线程池对象

        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

        //创建Runnable实例对象

        MyRunnable r = new MyRunnable();

 

        //自己创建线程对象的方式

        //Thread t = new Thread(r);

        //t.start(); ---> 调用MyRunnable中的run()

 

        //从线程池中获取线程对象,然后调用MyRunnable中的run()

        service.submit(r);

        //再获取个线程对象，调用MyRunnable中的run()

        service.submit(r);

        service.submit(r);

        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

 
        //关闭线程池

        //service.shutdown();

    }

}

// Runnable接口实现类

public class MyRunnable implements Runnable {

    @Override

    public void run() {

        System.out.println("我要一个教练");

 

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }
    
        System.out.println("教练来了： " + Thread.currentThread().getName());

        System.out.println("教我游泳,交完后，教练回到了游泳池");

    }

}        

 

（2）Callable接口

　　Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

 

　　ExecutorService：线程池类

　　<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

　　Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 

　　使用线程池中线程对象的步骤：

　　　　a.创建线程池对象

　　　　b.创建Callable接口子类对象

　　　　c.提交Callable接口子类对象

　　　　d.关闭线程池

 

public class ThreadPoolDemo {

    public static void main(String[] args) {

        //创建线程池对象

        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

        //创建Callable对象

        MyCallable c = new MyCallable();

 

        //从线程池中获取线程对象,然后调用MyRunnable中的run()

        service.submit(c);

 

        //再获取个教练

        service.submit(c);

        service.submit(c);

        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

 

        //关闭线程池

        //service.shutdown();

    }

}


//Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果

public class MyCallable implements Callable {

    @Override

    public Object call() throws Exception {

        System.out.println("我要一个教练:call");

        Thread.sleep(2000);

        System.out.println("教练来了： " + Thread.currentThread().getName());

        System.out.println("教我游泳,交完后,教练回到了游泳池");

        return null;
    
    }

}        

 

线程池实例：返回两个数相加的结果

 要求：通过线程池中的线程对象，使用Callable接口完成两个数求和操作

 Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 V get() ：获取Future对象中封装的数据结果

public class ThreadPoolDemo {

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

    //创建线程池对象

    ExecutorService threadPool = Executors.newFixedThreadPool(2);

 

    //创建一个Callable接口子类对象

    //MyCallable c = new MyCallable();

    MyCallable c = new MyCallable(100, 200);

    MyCallable c2 = new MyCallable(10, 20);

 

    //获取线程池中的线程，调用Callable接口子类对象中的call()方法, 完成求和操作
    
    //<Integer> Future<Integer> submit(Callable<Integer> task)

    // Future 结果对象

    Future<Integer> result = threadPool.submit(c);

    //此 Future 的 get 方法所返回的结果类型

    Integer sum = result.get();

    System.out.println("sum=" + sum);

 

    //再演示

    result = threadPool.submit(c2);

    sum = result.get();

    System.out.println("sum=" + sum);

    //关闭线程池(可以不关闭)

    }

}


//Callable接口实现类

public class MyCallable implements Callable<Integer> {

    //成员变量

    int x = 5;

    int y = 3;

    //构造方法

    public MyCallable(){

    }

    public MyCallable(int x, int y){

    this.x = x;

    this.y = y;

    }


    @Override

    public Integer call() throws Exception {
    return x+y;

    }

}

 

六、线程安全

1.什么是线程安全：

　　当多个线程访问某个方法时，不管你通过怎样的调用方式、或者说这些线程如何交替地执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。

　　无状态的对象，不包含任何的作用域，也没有去引用其他类中的域进行引用，它所执行的作用范围与执行结果只存在它这条线程的局部变量中，并且只能由正在执行的线程进行访问。当前线程的访问，不会对另一个访问同一个方法的线程造成任何的影响。也是线程安全的。

2.多线程时，如何保证线程安全

（1）synchronized关键字

　　synchronized关键字用来控制线程同步的，保证我们的线程在多线程环境下，不被多个线程同时执行，确保我们数据的完整性，使用方法一般是加在方法上。

public class ThreadDemo {

   int count = 0; // 记录方法的命中次数

   public synchronized void threadMethod(int j) {

       count++ ;

       int i = 1;

       j = j + i;
   }
}

　　注意：

　　　　a.synchronized锁的是括号里的对象，而不是代码；

　　　　b.对于非静态的synchronized方法，锁的是对象本身也就是this；

　　　　c.当synchronized锁住一个对象之后，别的线程如果想要获取锁对象，那么就必须等这个线程执行完释放锁对象之后才可以，否则一直处于等待状态;

　　　　d.在用的时候要注意缩小synchronized的使用范围，如果随意使用时很影响程序的性能，别的对象想拿到锁，结果你没用锁还一直把锁占用，这样就有点浪费资源。

（2）lock

　　Lock是在Java1.6被引入进来的，Lock的引入让锁有了可操作性：就是我们在需要的时候去手动的获取锁和释放锁，甚至我们还可以中断获取以及超时获取的同步特性，但是从使用上说Lock明显没有synchronized使用起来方便快捷。

　　与synchronized不同的是，Lock获取的所对象需要我们亲自去进行释放，为了防止我们代码出现异常，所以我们的释放锁操作放在finally中，因为finally中的代码无论如何都是会执行的。

private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子类

   private void method(Thread thread){
       lock.lock(); // 获取锁对象
       try {
           System.out.println("线程名："+thread.getName() + "获得了锁");
           // Thread.sleep(2000);
       }catch(Exception e){
           e.printStackTrace();
       } finally {
           System.out.println("线程名："+thread.getName() + "释放了锁");
           lock.unlock(); // 释放锁对象
       }
   }

 

　　Lock有几种获取锁的方式，例如：tryLock()这个方法跟Lock()是有区别的，Lock在获取锁的时候，如果拿不到锁，就一直处于等待状态，直到拿到锁；但是tryLock()却不是这样的，tryLock是有一个Boolean的返回值的，如果没有拿到锁，直接返回false，停止等待，它不会像Lock()那样去一直等待获取锁。

public static void main(String[] args) {
       LockTest lockTest = new LockTest();

       // 线程1
       Thread t1 = new Thread(new Runnable() {

           @Override
           public void run() {
               // Thread.currentThread()  返回当前线程的引用
               lockTest.method(Thread.currentThread());
           }
       }, "t1");

       // 线程2
       Thread t2 = new Thread(new Runnable() {

           @Override
           public void run() {
               lockTest.method(Thread.currentThread());
           }
       }, "t2");

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



//结果：
//线程名：t1获得了锁
//线程名：t1释放了锁
//线程名：t2获得了锁
//线程名：t2释放了锁

 

private void method(Thread thread){
       // lock.lock(); // 获取锁对象
       if (lock.tryLock()) {
           try {
               System.out.println("线程名："+thread.getName() + "获得了锁");
               // Thread.sleep(2000);
           }catch(Exception e){
               e.printStackTrace();
           } finally {
               System.out.println("线程名："+thread.getName() + "释放了锁");
               lock.unlock(); // 释放锁对象
           }
       }
   }


//结果：我们继续使用刚才的两个线程进行测试可以发现，在线程t1获取到锁之后，线程t2立马进来，然后发现锁已经被占用，那么这个时候它也不在继续等待。
//线程名：t1获得了锁
//线程名：t1释放了锁

 

private void method(Thread thread) throws InterruptedException {
       // lock.lock(); // 获取锁对象

       // 如果5秒内获取不到锁对象，那就不再等待
       if (lock.tryLock(5,TimeUnit.SECONDS)) {
           try {
               System.out.println("线程名："+thread.getName() + "获得了锁");
           }catch(Exception e){
               e.printStackTrace();
           } finally {
               System.out.println("线程名："+thread.getName() + "释放了锁");
               lock.unlock(); // 释放锁对象
           }
       }
   }


//结果：线程t2等到5秒获取到了锁对象，执行了任务代码
//线程名：t1获得了锁
//线程名：t1释放了锁
//线程名：t2获得了锁
//线程名：t2释放了锁

 

　　

 

 

 

 

 

 

 

 

 

学习参考：

https://blog.csdn.net/vbirdbest/article/details/81282163

https://blog.csdn.net/weixin_41319239/article/details/96917818

https://www.cnblogs.com/jmsjh/p/7762034.html

https://blog.csdn.net/beidaol/article/details/89135277