Java多线程详解-优快云博客

本文链接：https://blog.youkuaiyun.com/class2class/article/details/51707741

一、进程和线程的基础知识

1、进程和线程的概念

进程：运行中的应用程序称为进程，拥有系统资源（cpu、内存）

线程：进程中的一段代码，一个进程中可以有多段代码。本身不拥有资源（共享所在进程的资源）

在java中，程序入口被自动创建为主线程，在主线程中可以创建多个子线程。

区别：

1、是否占有资源问题

2、创建或撤销一个进程所需要的开销比创建或撤销一个线程所需要的开销大。

3、进程为重量级组件，线程为轻量级组件

多进程: 在操作系统中能同时运行多个任务(程序)

多线程: 在同一应用程序中有多个功能流同时执行

2、线程的主要特点

①、不能以一个文件名的方式独立存在在磁盘中；

②、不能单独执行，只有在进程启动后才可启动；

③、线程可以共享进程相同的内存（代码与数据）。

3、线程的主要用途

①、利用它可以完成重复性的工作（如实现动画、声音等的播放）。

②、从事一次性较费时的初始化工作（如网络连接、声音数据文件的加载）。

③、并发执行的运行效果（一个进程多个线程）以实现更复杂的功能

4、多线程（多个线程同时运行）程序的主要优点

①、可以减轻系统性能方面的瓶颈，因为可以并行操作；

②、提高CPU的处理器的效率，在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性；另一方面，在多CPU系统中，可以把不同的线程在不同的CPU中执行，真正做到同时处理多任务。

运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码
线程生命周期

6 一个java应用程序至少有几个线程？
至少有两个线程，一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。

7 多线程的好处：
1. 解决了一个进程能同时执行多个任务的问题。
2. 提高了资源的利用率。

多线程的弊端：
1. 增加cpu的负担。
2. 降低了一个进程中线程的执行概率。
3. 引发了线程安全问题。
4. 出现了死锁现象。
二、线程的创建和启动

其实看看API，从Thread的构造方法，就可以看出创建一个线程的方式:

方式一：
1. 自定义一个类继承Thread类。
2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
疑问：重写run方法的目的是什么？
每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。
3. 创建Thread的子类对象，并且调用start方法开启线程。

注意：一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。

public class Demo1 extends Thread {

    @Override  //把自定义线程的任务代码写在run方法中。
    public void run() {
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("自定义线程："+i);
        }
    }


    public static void main(String[] args) {
        //创建了自定义的线程对象。
        Demo1 d = new Demo1();
        //调用start方法启动线程
        d.start();

        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("main线程："+i);
        }
    }   
}

方式二

    1.  自定义一个类实现Runnable接口。
    2. 实现Runnable接口 的run方法，把自定义线程的任务定义在run方法上。
    3. 创建Runnable实现类对象。
    4. 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递。
    5. 调用Thread对象 的start方法开启一个线程。

举一反三两个问题

问题1： Runnable实现类的对象是线程对象吗？
       Runnable实现类的对象并 不是一个线程对象，只不过是实现了Runnable接口 的对象而已。
       只有是Thread或者是Thread的子类才是线程 对象。

问题2： 为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？
    作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。

推荐使用： 第二种。 实现Runable接口的。 
原因： 因为java单继承 ,多实现的。

public class MythreadRunnable {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    new Thread(new Runnable(){

        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println("this" + this);                                //runnable
            System.out.println("当前线程" + Thread.currentThread().getName());  //gouwa
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);   //gouwa
            }
        }

    },"gouwa").start();
    for(int i = 0 ; i < 100 ; i++){
        System.out.println(Thread.currentThread().getName()+":"+i);   //main
    }
    }

}

线程常用的方法：

Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
sleep() 线程睡眠指定的毫秒数。静态的方法那个线程执行了sleep方法代码那么就是那个线程睡眠。
currentThread() 返回当前的线程对象，该方法是一个静态的方法，注意：那个线程执行了 currentThread()代码就返回那个线程的对象。
getPriority() 返回当前线程对象的优先级默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ，默认是5）

public class Mythread  extends Thread{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
      Demo3 demo = new Demo3("zhangsan");
      demo.start();
      System.out.println("自定义线程的优先级："+demo.getPriority());  //线程的优先级默认是5
      System.out.println("主线程的优先级："+Thread.currentThread().getPriority());
      Thread mainthrad = Thread.currentThread();
      System.out.println("主线程的名字："+ mainthrad.getName());
}}


class Demo3 extends Thread {

    public Demo3(String name){
        super(name); //调用了Thread类的一个 参数的构造方法。
    }


    @Override
    public void run() {
        System.out.println("this:"+ this);
        System.out.println("当前线程对象：" + Thread.currentThread());

        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);


            try {
                Thread.sleep(1000);  //为什么在这里不能抛出异常，只能捕获？？ Thread类的run方法没有抛出异常类型，所以子类不能抛出异常类型。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


}}

出现线程安全问题的根本原因：
1. 存在两个或者两个以上的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。
java线程同步机制的方式：

方式一：同步代码块

        同步代码块的格式：
            synchronized(锁对象){
                需要被同步的代码...
            }

同步代码块要注意事项：
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
4. 多线程操作的锁对象必须是唯一共享的。否则无效。
5. 当同步代码块被执行完毕时候，锁就会被释放
看个代码

public class Mytickes {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SaleTicket thread1 = new SaleTicket("窗口1");
        SaleTicket thread2 = new SaleTicket("窗口2");
        SaleTicket thread3 = new SaleTicket("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();

    }

}
class SaleTicket extends Thread{
    static int num = 50;
    static Object suo = new Object();
    public SaleTicket(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        while(true){
            synchronized (suo) {
                if(num > 0){
                    System.out.println(Thread.currentThread().getName() + " 售出了第" + num + "号票");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    num--;
                }else{
                    System.out.println("卖完了");
                    break;
                }
            }
        }
    }

}

方式二：同步函数同步函数就是使用synchronized修饰一个函数。
同步函数要注意的事项：
1. 如果是一个非静态的同步函数的锁对象是this对象，如果是静态的同步函数的锁对象是当前函数所属的类的字节码文件（class对象）必须要静态否则同步失效，静态也有可能不成功，因为会让同步代码块被整个锁住。
2. 同步函数的锁对象是固定的，不能由你来指定的。

推荐使用：同步代码块。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定的，不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了，只有当整个函数被执行完毕才会释放锁，会有使用局限性。

public class DemoBack {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BankThread thread1 = new BankThread("老公");
        BankThread thread2 = new BankThread("老婆");
        thread1.start();
        thread2.start();

    }

}
class BankThread extends Thread {
    static int count =5000;

    public BankThread(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();

            getMoney();

    }

    private static synchronized void getMoney() {
        while(true){
            if(count>0){
                System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");
                count-=1000;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else{
                System.out.println("取光了");
                break;

            }

    }}

}
此例子的执行结果就是，仅是一个线程取走所有金钱，本质还是锁的范围太大。

三多线程通讯问题
举例：一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.
经典的生产者消费者模型
线程有以下几种方法：

wait(): 等待如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
notify()：唤醒唤醒线程池等待线程其中的一个。
notifyAll() : 唤醒线程池所有等待线程。

wait与notify方法要注意的事项：
1. wait方法与notify方法是属于Object对象的。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用。
3. wait方法与notify方法必需要由锁对象调用。
代码片：


public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Product p = new Product();
        Producer producer = new Producer(p);
        Customer cuntomer = new Customer(p);
        producer.start();
        cuntomer.start();

    }

}
class Product{
    String name;
    double price;
    boolean flag = false;
}
class Producer extends  Thread{
    Product p;

    public Producer(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        int i =0;
        while(true){
            synchronized (p) {
                if(p.flag == false){
                    if(i%2==0){
                        p.name = "apple";
                        p.price = 6.5;
                    }else{
                        p.name = "banner";
                        p.price = 2.0;
                    }
                    System.out.println("生产者生产出来 " + p.name + "价格是 " + p.price);
                    p.flag = true;
                    i++;
                    p.notifyAll();
                }else{
                    try {
                        System.out.println("生产者在等待");
                        p.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }

    }

}
class Customer extends Thread{
    Product p;

    public Customer(Product p) {
        this.p = p;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        while(true){
            synchronized (p) {
                if(p.flag ==true){
                    System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
                    p.flag = false;
                    p.notifyAll();
                }else{
                    try {
                        System.out.println("消费者在等待");
                        p.wait();

                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        }
    }

}

生产者消费者模型

生产者生产出来 banner价格是 2.0
生产者在等待
消费者消费了banner 价格：2.0
消费者在等待
生产者生产出来 apple价格是 6.5
生产者在等待
消费者消费了apple 价格：6.5
消费者在等待
生产者生产出来 banner价格是 2.0
生产者在等待
消费者消费了banner 价格：2.0
消费者在等待
生产者生产出来 apple价格是 6.5
生产者在等待
消费者消费了apple 价格：6.5

wait() 一个线程如果执行了此方法，该线程会进入一个以锁对象为标示符的线程池中去等待。
notify() 如果一个线程执行了该方法，就会唤醒以锁对象为标示符的线程池中去唤醒其中一个线程。

四线程的停止

线程的停止：
1. 停止一个线程我们一般都会通过一个变量去控制的。
2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用。

代码看：

public class Demo6 extends Thread {

    boolean flag = true;

    public Demo6(String name){
        super(name);
    }


    @Override
    public synchronized void run() {
        int i = 0 ;
        while(flag){
            try {
                this.wait(); //狗娃等待..

            } catch (InterruptedException e) {
                System.out.println("接收到了异常了....");
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
            i++;
        }
    }



    public static void main(String[] args) {
        Demo6 d = new Demo6("狗娃");
        d.setPriority(10);
        d.start();

        for(int i = 0 ; i<100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //当主线程的i是80的时候停止狗娃线程。
            //d.interrupt();  // interrupt()根本就是无法停止一个线程。
            if(i==80){
                d.flag = false;
                d.interrupt(); //把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException。 
                /*synchronized (d) {                    
                    d.notify();
                }*/


            }

        }


    }

}