Java之多线程

最新推荐文章于 2024-08-16 23:08:28 发布

荼蘼2021

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量75

点赞数

分类专栏： Java基础文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43915128/article/details/120443967

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

概念

线程与进程

进程：一个内存中运行的应用程序，每个进程都有独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的依次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

同步与异步

同步： 排队执行，线程安全，效率低
异步： 同时执行，线程不安全，效率高
比如：A请求某个资源，但是该资源被B占用着，如果同步机制存在，则A将会等待B使用完；如果同步机制不存在，A仍然可以请求B

并行与并发

并行： 同一时间段内，执行多个任务
并发： 同一时刻，执行多个任务

线程调度方式

分时调度： 所有线程轮流使用CPU的使用权，平均分配每个进程占用CPU的时间
抢占式调度： 优先让优先级高的线程使用CPU，如果线程优先级相同，会随机选择一个（线程随机性）。
Java使用的就是抢占式调度

Java中的线程

线程就好比一辆货车，run方法（任务）就相当于货物，把货物**(run)装上货车(Thread)运输到目的地(执行run方法)**

实现方式

继承Thread

通过继承Thread类，实现run方法，调用start方法启动。因为Java是单继承，实现了Thread类就没办法继承其他类。这种方式在继承上略显笨拙。

public class Test {
    public static void main(String[] args) {
        new MyThread().start();//创建自定义线程对象，调用start()开启
        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
//线程类
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}

打印结果：

main.....0
Thread-0.....0
Thread-0.....1
main.....1
main.....2
Thread-0.....2
main.....3
Thread-0.....3
Thread-0.....4
main.....4
Thread-0.....5
main.....5
main.....6
Thread-0.....6
Thread-0.....7
main.....7
Thread-0.....8
main.....8
Thread-0.....9
main.....9

main线程和Thread-0线程抢占CPU，谁抢到谁执行

实现Runnable

通过实现Runnable接口，实现他的run方法，调用start方法启动。该方式避免了继承Thread方式的笨拙。

public class Test {
    public static void main(String[] args) {
        //创建一个任务对象
        MyRunnable myRunnable = new MyRunnable();
        //将任务装入线程，并开启
        new Thread(myRunnable).start();

        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}

打印结果：

Thread-0.....0
main.....0
main.....1
Thread-0.....1
Thread-0.....2
main.....2
main.....3
Thread-0.....3
Thread-0.....4
main.....4
Thread-0.....5
main.....5
main.....6
Thread-0.....6
Thread-0.....7
main.....7
main.....8
Thread-0.....8
Thread-0.....9
main.....9

实现Callable

这种方式同前两种不同，实现Callable可以具有返回值，返回给main线程

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建任务
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(callable);
        //将任务装入线程
        new Thread(task).start();
        //如果不调用get()则跟前两种线程一样，调用get()后，该线程阻塞，等待执行完后再往下执行
        int a = task.get();
        System.out.println("返回："+a);
        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
    }
}
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        for (int i = 0;i < 10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"....."+i);
        }
        return 100;
    }
}

打印结果：

Thread-0.....0
Thread-0.....1
Thread-0.....2
Thread-0.....3
Thread-0.....4
Thread-0.....5
Thread-0.....6
Thread-0.....7
Thread-0.....8
Thread-0.....9
返回：100
main.....0
main.....1
main.....2
main.....3
main.....4
main.....5
main.....6
main.....7
main.....8
main.....9

Future接口

V get()
等待线程执行结束，返回结果
V get(long timeout, TimeUnit unit)
传一个时间和时间单位，最多等待这些时间，否则抛出超时异常
boolean isCancelled()
如果任务在执行完前被取消返回true，否则返回false
boolean cancel(boolean mayInterruptIfRunning)
尝试取消该任务
boolean isDone()
返回 true如果任务已完成

线程状态

在Thread的内部类State中枚举了六种线程的状态

new（初始状态）
尚未启动的线程处于此状态
runnable（可运行状态）
在Java虚拟机中执行的线程处于此状态。
blocked（阻塞状态）
被阻塞等待监视器锁定的线程处于此状态。
waiting（等待状态）
正在等待另一个线程执行特定动作的线程处于此状态。
timed_waiting（超时等待）
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
terminated
已退出的线程处于此状态。

当线程被创建时处于new状态
```
Thread t = new Thread();
```
当线程被调用start()时，如果获得了cpu的执行时间则是runnable状态；否则进入blocked状态
```
t.start();
```
当线程处于runnable状态，如果调用了线程对象的wait()、Thread.join()或LockSupport.park()则进入waiting状态
```
//1.
t.wait();
//2.
Thread.join();
//3.
LockSupport.park();
```
当线程处于runnable状态，如果调用了Thread.sleep(long)、线程对象的wait(long)、Thread.join(long)、LockSupport.parkNanos或LockSupport.parkUntil等方法则进入timed_waiting状态
当线程处于runnable状态，如果丢失CPU的执行时间，则进入blocked状态
当线程处于runnable状态，run方法执行结束，则进入terminated状态
当线程处于timed_waiting状态，如果休眠时间结束或被唤醒，且此时CPU空闲则进入runnable状态，否则进入blocked状态
当线程处于waiting状态，调用线程对象的notify()或notifyAll()，则休眠结束，若此时CPU空闲则进入runnable状态，否则进入blocked状态
当线程处于blocked状态，如果抢到CPU的执行时间，则进入runnable状态
如图所示：

Thread常用方法

static Thread currentThread()
获取当前线程
String getName()
获取线程的名称
void setName(String name)
设置线程的名称
int getPriority()
获取线程的优先级
long getId()
获取线程的标识符
Thread.State getState()
获取线程的状态
void interrupt()
中断线程，但实际上并不会被中断，只是给线程设置一个中断标志
static boolean interrupted()
当前线程是否中断，并且可以清除中断标志
boolean isInterrupted()
该线程是否被中断
boolean isAlive()
该线程是否存活
boolean isDaemon()
该线程是否是守护线程
守护线程： 为非守护线程提供服务，依赖与非守护线程
void join()
在一个线程中调用另一个线程的join(),将等待另一个线程执行完后才继续本线程。
void join(long millis)
void join(long millis, int nanos)
void run()
如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回
void start()
导致此线程开始执行; Java虚拟机调用此线程的run方法
static void sleep(long millis)
使当前执行的线程睡眠
static void yield()
丢弃CPU执行时间，让别的就绪状态线程运行（切换）

线程安全问题

卖票案例：

public class TestTicket {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);
        t1.start();
        t2.start();
        t3.start();
    }

}
class MyRunnable implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖出"+(ticket--)+"号票");
            }
        }
    }
}

打印结果：

Thread-0卖出10号票
Thread-1卖出8号票
Thread-2卖出9号票
Thread-1卖出7号票
Thread-2卖出6号票
Thread-0卖出7号票
Thread-0卖出4号票
Thread-1卖出3号票
Thread-2卖出5号票
Thread-2卖出2号票
Thread-0卖出2号票
Thread-1卖出1号票

多个窗口共享10张票，会出现重复卖票或不存在的票
解决方案：

同步代码块

public class TestTicket {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);
        t1.start();
        t2.start();
        t3.start();
    }

}
class MyRunnable implements Runnable{
    private int ticket = 10;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
                }
            }
        }
    }
}

打印结果：

Thread-0卖出10号票
Thread-0卖出9号票
Thread-2卖出8号票
Thread-2卖出7号票
Thread-2卖出6号票
Thread-2卖出5号票
Thread-2卖出4号票
Thread-2卖出3号票
Thread-2卖出2号票
Thread-2卖出1号票

同步方法

public class TestTicket {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);
        t2.start();
        t1.start();
        t3.start();
    }
}
class MyRunnable implements Runnable {
    private int ticket = 10;
    @Override
    public void run() {
        while (true) {
            sale();
        }
    }
    public synchronized void sale() {
        if (ticket > 0) {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
        }
    }
}

打印结果：

Thread-1卖出10号票
Thread-1卖出9号票
Thread-1卖出8号票
Thread-0卖出7号票
Thread-0卖出6号票
Thread-2卖出5号票
Thread-2卖出4号票
Thread-2卖出3号票
Thread-2卖出2号票
Thread-2卖出1号票

Lock

public class TestTicket {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);
        t2.start();
        t1.start();
        t3.start();
    }

}

class MyRunnable implements Runnable {
    private int ticket = 10;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(300);
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
            } else {
	            lock.unlock();
                break;
            }
        }
    }
}

执行结果：

Thread-2卖出10号票
Thread-1卖出9号票
Thread-0卖出8号票
Thread-2卖出7号票
Thread-1卖出6号票
Thread-0卖出5号票
Thread-2卖出4号票
Thread-1卖出3号票
Thread-0卖出2号票
Thread-2卖出1号票

synchronized关键字

修饰代码块，称为同步代码块；
作用范围：大括号内；
作用对象：小括号内的对象
this：该类的实例对象作为锁
xx.class：该类的类对象作为锁
obj：任意类的实例对象作为锁
修饰方法，称为同步方法
作用范围：整个方法
作用对象：调用方法的对象
修饰静态方法
作用范围：整个静态方法
作用对象：这个类的所有对象

线程间的通信

多个线程在处理同一个资源，但是处理的动作(线程的任务)不相同

为什么要处理线程间通信？

多个线程在并发执行时，在默认情况下CPU是随即切换线程的，当我们需要多个线程来完成一件任务，并且我们希望他们有规律的执行，就需要多个线程协调通信，以此达到多线程共同操作一份数据

如何保证线程间通信有效利用资源：

多个线程操作同一个线程，并且任务不同时，需要线程通信来帮助解决线程之间对同一变量的使用或操作(即多个线程操作一份数据)避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。这种手段就是等待唤醒机制

生产者与消费者

模拟：肯德基与顾客，肯德基生产一个食物，顾客吃一个食物。此时食物就是那个共同的资源，肯德基和顾客则是对公共资源操作的线程。

/**
 * 食物
 */
class Food {
    private String food;
    private boolean have = false;

    public Food(String food, boolean have) {
        this.food = food;
        this.have = have;
    }

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    public boolean isHave() {
        return have;
    }

    public void setHave(boolean have) {
        this.have = have;
    }
}

class KFC extends Thread {
    private Food food;

    public KFC(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        //循环生产food
        while (true) {
            synchronized (food) {
                if (food.isHave()) {//有食物
                    try {
                        food.wait();//等着吃没了
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } //无食物
                try {
                    System.out.println(Thread.currentThread().getName() + "开始生产食物");
                    Thread.sleep(1000);
                    food.setHave(true);
                    food.notify();//唤醒顾客
                    System.out.println(Thread.currentThread().getName() + food.getFood() + "做好了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class Customer extends Thread {
    private Food food;

    public Customer(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        //一直吃东西
        while (true) {
            synchronized (food) {
                if (!food.isHave()) {//有食物，开吃
                    try {
                        food.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                System.out.println(Thread.currentThread().getName() + "开饭了");
                food.setHave(false);
                food.notify();//开吃了，等会再做
                System.out.println(Thread.currentThread().getName() + "吃没了，再做吧");
            }
        }
    }
}

public class TestTicket {
    public static void main(String[] args) {
        Food food = new Food("汉堡", true);
        Customer customer = new Customer(food);
        customer.setName("顾客");
        KFC kfc = new KFC(food);
        kfc.setName("肯德基");
        kfc.start();
        customer.start();
    }
}

注意：共享的食物对象从头到尾只能是刚开始的那个食物，不能中途new

打印结果：

顾客开饭了
顾客吃没了，再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
顾客吃没了，再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
顾客吃没了，再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
....

线程池

原理：
线程池就是一个容器，当程序第一次启动时，创建多个线程，保存到一个集合，当我们使用时，可以从集合中取出线程使用
优点：
降低资源消耗
提高响应速度
方便管理
分类：

缓存线程池
使用时，判断池内是否含有空闲线程，存在则使用；不存在创建线程，放入线程池在使用

public class TestPool {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
    }
}

打印结果：

pool-1-thread-1
pool-1-thread-4
pool-1-thread-5
pool-1-thread-2
pool-1-thread-3

定长缓存池
使用时，判断池内是否含有空闲线程，存在则使用；不存在，若线程池已满，等待其他线程结束；若线程池不满，创建线程放入线程池在使用

public class TestPool {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        ExecutorService service = Executors.newFixedThreadPool(3);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
    }
}

打印结果：

pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1

单线程线程池
使用时，判断线程池的线程是否空闲，空闲则使用，不空闲则等待

public class TestPool {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
    }
}

打印结果：

pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1

周期性任务定长线程池
周期任务：定长线程池
使用时，判断线程池的线程是否空闲，存在则使用；不存在，若线程池已满，等待其他线程结束；若线程池不满，创建线程放入线程池在使用

public class TestPool {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        /**
         * 定时执行一次
         * 任务,时间数,时间单位
         */
        ExecutorService service = Executors.newScheduledThreadPool(3);
        ((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);

    }
}

打印结果：

pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1

周期性任务执行时：
定时执行，当某个时机触发时，自动执行某任务

public class TestPool {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        /**
         * 定时执行一次
         * 任务,延迟时间,周期时间数,时间单位
         */
        ExecutorService service = Executors.newScheduledThreadPool(3);
        ((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
        ((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);

    }
}

打印结果：

pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3

荼蘼2021

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java之多线程

多线程概念线程与进程同步与异步并行与并发线程调度方式Java中的线程实现方式继承Thread实现Runnable实现CallableFuture接口线程状态Thread常用方法线程安全问题synchronized关键字线程间的通信为什么要处理线程间通信？如何保证线程间通信有效利用资源：生产者与消费者线程池概念线程与进程进程：一个内存中运行的应用程序，每个进程都有独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的依次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运
复制链接

扫一扫

专栏目录