多线程

最新推荐文章于 2023-05-19 14:49:58 发布

Please Sit Down

最新推荐文章于 2023-05-19 14:49:58 发布

阅读量275

点赞数

分类专栏： Java 多线程

本文链接：https://blog.csdn.net/qq_36942720/article/details/114076815

版权

Java 同时被 2 个专栏收录

66 篇文章 6 订阅

订阅专栏

多线程

7 篇文章 0 订阅

订阅专栏

创建线程的三种方式：

public static void main(String[] args) throws Exception{
    // 继承Thread类
    new Thread(){       //1,继承Thread类
        @Override
        public void run() {     //2,重写run方法
            for (int i = 0; i < 100; i++) {     //3,将要执行的代码,写在run方法中
                System.out.println("thread......");
            }
        }
    }.start();          //4,开启线程

    // 实现Runnable接口
    new Thread( new Runnable(){     //1,将Runnable的子类对象传递给Thread的构造方法
        @Override
        public void run() {     //2,重写run方法
            for (int i = 0; i < 100; i++) { //3,将要执行的代码,写在run方法中
                System.out.println("runnable......");
            }
        }
    }).start();     //4,开启线程

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

    // 实现Callable接口
    // Callable和Runnable的区别在于Runnable的run方法没有返回值，Callable的call方法有返回值
    MyCallableDemo callable = new MyCallableDemo();
    FutureTask<String> task = new FutureTask(callable);
    new Thread(task).start();
    try {
        System.out.println(task.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
}
class MyCallableDemo implements Callable<Object>{
    @Override
    public Object call() throws Exception {
        System.out.println("callable call method");
        return "success";
    }
}

以上程序实际创建了5个线程对象：

继承Thread类线程、实现Runnable接口线程、main线程、实现Callable接口线程、gc回收线程（记住）

继承Thread类实现：

1、创建自定义类继承Thread类。

2、重写Thread类中的run方法，完成线程的业务逻辑代码

代码实现：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread......");
    }
    public static void main(String[] args) {
        new MyThread().start();
    }
}

实现Runnable接口实现：

1、创建自定义类并实现Runnable接口。

2、实现run方法，编写该线程的业务逻辑。

3、实例化Runnable对象和Thread对象，同时将Runnable对象赋给Thread对象。

代码实现：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("MyRunnable......");
    }
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();
    }
}

实现Callable接口原理：

面试：

①run方法和start方法的区别？

run方法相当于普通方法调用，不会产生多线程的效果。

start方法是开启线程争夺CPU资源，才会产生多线程的效果。

【注】实际开发中推荐使用实现Runnable接口的方式来完成，因为可以做到解耦合。

②sleep()和wait()区别？

sleep是让当前线程休眠，wait是让访问当前对象的线程休眠。sleep不会释放锁，wait会释放锁。

线程的状态：

1、创建状态：实例化一个新的线程对象，未启动。new Thread()

2、就绪状态：创建好的线程对象调用start方法完成启动，进入线程池等待抢占CPU资源。start()

3、运行状态：线程对象获取了CPU资源，在分配给它的时间片段内执行任务。得到CPU的执行权

4、阻塞状态：正在运行状态的线程暂停任务的执行，释放所占用的CPU资源。sleep(),wait()

5、终止状态：线程运行完毕或者因为异常导致该线程意外终止运行。run()结束,stop()

线程休眠：让当前线程暂停执行，从运行状态进入阻塞状态，将CPU资源让给其他线程的一种调度方式，通过sleep() 来实现。sleep()是线程Thread类中的一个本地方法，可以通过对象调用{myThread.sleep()}也可以通过类调用{Thread.sleep()}方法。

线程合并：将指定的线程加入到当前线程中，合并成一个线程，由两个线程交替执行变成一个线程中的两个子线程顺序执行。线程甲和线程乙，甲执行到某个时间节点的时候调用乙的join方法，则表示从当前时间开始CPU资源被线程乙独占，线程甲进入阻塞状态，直到线程乙执行完毕，线程甲进入就绪状态，等待获取CPU资源，进行执行。

【备注】：有时间参数的join，传入的时间参数是x，当子线程合并到主线程之后，子线程会独占CPU资源，释放的节点从合并的那一刻起到x时间结束，无论子线程是否执行完毕，都会释放CPU资源。没有时间参数的join，当子线程合并到主线程之后，子线程会独占CPU资源，释放的节点是子线程的任务全部执行完毕。

public static void main(String[] args) throws Exception{
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("thread......");
            }
        }
    };
    Thread thread = new Thread(runnable);
    thread.start();
    for (int i = 0; i < 20; i++) {
        if(i==5){
            thread.join(200);//200毫秒后thread线程结束合并操作，两个线程继续争夺CPU资源
        }
        System.out.println("main......");
    }
}

线程礼让：线程礼让是指在某个特定的时间点，让线程暂停抢占CPU资源的行为，从运行状态或就绪状态来到阻塞状态，从而讲CPU资源让给其他线程来使用。只是在某个时间点去礼让，过了这个时间点，依然会争夺CPU资源。使用方法：在需要礼让的地方加上就可以。

this.yield();   // 当前对象调用(只适合继承Thread类使用，实现Runnable接口无法使用)
Thread.yield(); // 静态类调用
Thread.currentThread().yield(); // 当前线程调用

线程中断：

线程停止运行的情况：执行完毕自动停止、执行过程中遇到错误抛出异常停止、执行过程中根据需求手动停止

中断线程方法：

public void stop()：新版本的JDK已经不推荐使用

public void interrupt()：实例方法，当一个线程对象调用该方法时，表示中断当前线程对象。每个线程对象都是通过一个标志位来判断当前是否为中断状态。

public boolean isInterrupted()：用来获取当前线程对象的标志位；true表示清除了标志位，当前线程已经中断；false表示没有清除标志位，当前对象没有中断。

同步代码块(锁)：

同步和异步：同步是指排队按顺序，依次执行；异步是指没有顺序不排队，同时执行。

synchronized：加锁的必须是对象，对同一个对象上锁才能达到同步的目的。

【面试】synchronized锁定的是什么？

1、synchronized修饰非静态方法，锁定方法的调用者(也就是锁的对象)

2、synchronized修饰静态方法，锁定的是类

3、synchronized静态方法和实例方法同时存在，静态方法锁定的是类，实例方法锁定的是对象

例子：

class Account implements Runnable{
    private static Integer num = 0;
    @Override
    public synchronized void run() {
        num++;
        try {
            Thread.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"------"+num);
    }
}

如果是一个Account对象：

结果正常输出：

如果是两个Account对象：

结果错误输出：

原因：操作的是两个对象，锁住的是不同的两个Account对象。

修改代码后正常输出，此时锁住的是synchronized代码块中的函数，被锁的对象是Account。

结论：是否同步关键看多个线程对象使用的是否是同一个资源，如果是同一个资源（共享）下加锁，就会实现同步；如果不是同一个资源，数据不共享，加锁，也不会实现同步。

多线程下的单例模式：

public class SingletonDemo {
    // volatile的作用是可以使内存中的数据对象线程可见
    // 主内存对线程是不可见的，添加volatile关键字之后，主内存对线程可见
    // 使用volatile后直接跳过工作内存复制一份的情况，进行主内存操作判断是否为空
    private volatile static  SingletonDemo singleton;
    private SingletonDemo(){
        System.out.println("创建了单例对象！");
    }
    // double check
    public static SingletonDemo getInstance(){
        //必须是一个唯一的对象
        if(singleton == null){
            synchronized (SingletonDemo.class){
                if(singleton == null){
                    singleton = new SingletonDemo();
                }
            }
        }
        return singleton;
    }
}

死锁：哲学家进餐问题

public class DeadLock {
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    synchronized(s1) {
                        System.out.println(Thread.currentThread().getName()+".拿到"+s1+"等待"+s2);
                        synchronized(s2) {
                            System.out.println(Thread.currentThread().getName()+".拿到"+s2+"开吃");
                        }
                    }
                }
            }
        },"线程甲").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    synchronized(s2) {
                        System.out.println(Thread.currentThread().getName()+".拿到"+s2+"等待"+s1);
                        synchronized(s1) {
                            System.out.println(Thread.currentThread().getName()+".拿到"+s1+"开吃");
                        }
                    }
                }
            }
        },"线程乙").start();
    }
}

重入锁ReentrantLock：

ReentrantLoc是对synchronzied的升级，是Lock接口的实现类，是通过JDK实现的（通过API操作，调对象的方法），可以给同一个资源添加多把锁，必须手动释放锁，上了几把锁就要释放几把锁操作。

常用方法：lock()、unlock()、tryLock()、tryLock(long, TimeUnit)、lockInterruptibly()可中断锁

// 默认非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}
// true公平锁，false非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

公平锁和非公平锁的区别：

公平锁：线程同步时，多个线程排队，依次执行

非公平锁：线程同步时，可以插队

使用Lock锁，就不能通过wait和notify来暂停线程和唤醒线程，而应该使用Condition的await和signal来暂停和唤醒线程。