Java线程创建与管理：从基础到高级-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_53303967/article/details/130092684

创建子线程

继承Thread类

继承Thread类，重写Thread类的run()方法，然后使用start()启动

public class TestThread {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主线程，运行中" + i);
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是子线程，运行中" + i);
        }
    }
}

2.实现Runnable接口

实现Runnable接口，实现run()方法，通过new Thread(new 实现Runnable接口的类 )的start()方法启动线程

public class TestThread {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Thread myThread = new Thread(new MyThread());
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主线程，运行中=====" + i);
        }
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我是子线程，运行中---------" + i);
        }
    }
}

3.实现Callable<>类

通过Callable接口创建线程可以是线程返回一个值给主线程，需要实现Callable类的call()方法，指定返回值的泛型，通过FutureTask类代理自定义的方法类，然后通过Thread类的start()方法启动，
通过FutureTask类的get()方法可以可以得到返回值

public class TestThread {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        MyThread myThread1 = new MyThread();//创建自定义对象
        FutureTask<Integer> futureTask = new FutureTask<>(myThread1);//利用FutureTask对象接收
        Thread myThread = new Thread(futureTask);//通过代理模式创建线程对象
        myThread.start();
        try {
            System.out.println("子线程返回值"+futureTask.get());//通过代理FutureTask可以得到线程返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() {
        int i = 0;
        for (; i < 10; i++) {
            System.out.println("我是子线程，运行中---------" + i);
        }
        return i;
    }
}

函数式接口

定义

对于只定义了一个抽象方法的接口，可以称之为函数式接口
如Runnable接口：

@FunctionalInterface
public interface Runnable {
    void run();
}

运用

可以使用lamda表达式实列化函数式接口；
可以在用runnable接口创建函数时直接使用lamda表达式实现接口

public class TestThread {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Thread myThread = new Thread(()-{
            for (int i = 0; i < 10; i++) {
                System.out.println("我是子线程，运行中---------" + i);
            }
        });//使用lamda表达式创建Runnable函数式接口
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主线程，运行中=====" + i);
        }
    }
}
//class MyThread implements Runnable{
//    @Override
//    public void run() {
//        for (int i = 0; i < 10; i++) {
//            System.out.println("我是子线程，运行中---------" + i);
//        }
//    }
//}

常用线程方法

线程休眠

Thread.sleep(毫秒数);
在代码中使用这个静态方法，会让当前线程立即放弃cpu和cpu竞争，指定时间后再重新进入cpu竞争状态

线程礼让

Thread.yield();
在代码中使用这个静态方法后，会让当前线程立即放弃cpu，让cpu重新开启线程调度，当前线程可能会被再次调度执行

线程强制执行

thread.join();
Thread类的普通方法，使用对象调用，会让调用对象所对应的线程强制执行并且不让出cpu资源，只有在强制执行的线程执行完毕后才会让出cpu资源

获取线程状态

thread.getState();
Thread类的普通方法，使用对象调用，会返回当前对象所对应线程的状态

设置线程优先级

thread.setPriority(a); //a的取值范围是1到10，不在这个范围会报错线程优先级默认为5
Thread类的普通方法，使用对象调用，优先级越高，被cpu调用的机会越大

设置守护线程

myThread.setDaemon(true);
Thread类的普通方法，使用对象调用，会让对应线程被设置会守护线程
线程分为用户线程和守护线程，默认为用户线程
虚拟机必须保证用户线程执行完后才会结束程序
虚拟机不会保证守护线程执行完毕

synchronized与Lock

锁的概念

当一个线程设置一个资源不允许其他线程使用时，就是加锁
当该线程允许其他线程使用时，就是解锁

synchronized关键字

synchronized时java中的一个关键字，可以用在静态方法，普通方法和代码块前，使资源加锁
用在静态方法前，锁的是当前的类，不是类的对象
用在成员方法前，锁的是当前的对象
用在代码块前，需要指定需要锁的变量或者类，一个或者多个
synchronized是自动锁，不需要手动解锁
是一个重量级锁，很消耗cpu资源

Lock接口

Lock lock=new ReentrantLock();
通过这个方式可以获取当前线程的锁，锁的细粒度比synchronized更低
lock.lock(); //加锁
lock.unlock(); //解锁，推荐放在finally {}中

线程等待与唤醒

thread.wait(); //使当前对象对应的线程等待 TERMINATED状态
thread.notify(); //使当前对应线程的对象唤醒 RUNNABLE状态
thread.notifyAll(); //唤醒所有线程

Condition精确唤醒

通过Lock接口获取Condition对象，await()等待，signal()唤醒，更精确的控制

集合类的安全问题

new ArrayList<>();
new HashMap<>();
在多线程中，上面两个集合在插入和删除使会出现错误，因为没有加锁
new CopyOnWriteArrayList<>();
new ConcurrentHashMap<>();
然后就引入了安全集合类，CopyOnWriteArrayList底层使用Lock接口实现安全，ConcurrentHashMap底层使用synchronized锁代码块实现安全，在多线程中插入和删除不会出现锁安全问题

常用工具类

减法计数器工具类CountDownLatch

加法计数器工具类CyclicBarrier

信号量工具类Semaphore

读写锁ReadWriteLock

读读两锁可以共存
读写可以共存
写写不可以共存

阻塞队列BlockingDeque接口

方式	抛出异常	有返回值，不跑出异常	阻塞，等待	超时等待
添加元素	add	offer	put	offer(value,时间,时间单位)
移除元素	remove	poll	take	poll(时间,时间单位)
返回首元素	element	peek

抛出异常在队列满时添加，在队列为0时删除或者返回首元素会抛出异常
有返回值，不跑出异常会有一个返回值，不会抛出异常
阻塞，等待会一直阻塞，直到满足条件后执行操作
超时等待会阻塞指定时间，超时后取消操作

同步队列SynchronousQueue

SynchronousQueue作为阻塞队列的时候，对于每一个take的线程会阻塞直到有一个put的线程放入元素为止，反之亦然。
在SynchronousQueue内部没有任何存放元素的能力，可以理解为容量为 0。所以类似peek操作或者迭代器操作也是无效的，元素只能通过put类操作或者take类操作才有效。
SynchronousQueue支持支持生产者和消费者等待的公平性策略。默认情况下：非公平。
如果是公平锁的话可以保证当前第一个队首的线程是等待时间最长的线程，这时可以视SynchronousQueue为一个FIFO队列。
SynchronousQueue 提供两种实现方式，分别是栈和队列的方式实现。这两种实现方式中，栈是属于非公平的策略，队列是属于公平策略。