JavaSE学习笔记(四)：多线程

板牙叮咚

已于 2022-04-15 21:32:12 修改

阅读量410

点赞数 2

分类专栏： JavaSE学习文章标签： java 开发语言学习经验分享

于 2022-03-27 14:42:41 首次发布

本文链接：https://blog.csdn.net/weixin_46476301/article/details/123771853

版权

JavaSE学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

3.解决线程安全问题的方式三：Lock锁 --- JDK5.0新增

4.比较创建线程方法：继承Thread方式和实现Runnable接口方式

5.实现Callable接口(JDK5.0新增)

背景

以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

优点

1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 2.提高计算机系统CPU的利用率 3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

一、基本概念

1.程序

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

2.进程

进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
如：运行中的QQ，运行中的MP3播放器

3.线程

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
一个进程中的多个线程共享相同的内存单元／内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

4.程序与进程对比

程序是静态的，进程是动态的
》进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

5.线程的分类

二、多线程的创建和使用

1.继承于Thread类

步骤：

1.创建一个继承于Thread类的子类，
2.重写Thread类的run()-->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象。
4.通过此对象调用start()

//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
    //重写Thread类的run()
    @Override
    public void run() {
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ②调用当前线程的run()
        t1.start();

        //如下操作仍在main线程中执行的
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i + "***main()***");
            }
        }
    }
}

1.1Thread类中的常用方法：

1. start()：启动当前线程：调用当前线程的run()
2. run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread ()：静态方法，返回执行当前代码的线程
4.qetName()；获取当前线程的名字
5.setName()：设置当前线程的名字；
6. yield()：释放当前cpu的执行权
7、join()：在线程a中调用线程b的ioin()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a方向结束阻塞状态。8. stop()：己过时。当执行此方法时，强制结束当前线程。
9. sleep(long millitime)：让当前线程“缝隙”指定的millitime蓬勃。在指定的millitime蓬秒时间内，当前，线程是阻塞状态。
10.isAlive()：判断当前线程是否存活

11.wait():让当前进程进入阻塞状态

12.notify():唤醒某一原本处于阻塞状态的进程

13.notifyAll():唤醒所有原本处于阻塞状态的进程

14.suspend():已过时，将线程挂起

15.resume():已过时，将挂起线程复活继续执行

1.2线程的优先级

1.
MAXPRIORITY :1θ
MINPRIORITY :1
NORMPRIORITY ：5-->默认优先级

2.如何获取和设置当前线程的优先级：
getPriority ()：获取线程的优先级
setPriority (int p)：设置线程的优先级

注意：优先级高的线程比优先级低的线程具有比较高的概率会被优先执行，但不是百分之一百优先被执行

1.3同步代码块解决线程安全问题

class Windows extends Thread{

    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while(true){
            //正确的
//            synchronized (obj) {
            synchronized (Windows.class){   //Class clazz = Windows.class
                //错误的，因为此时this表示的是t1,t2,t3三个对象
//            synchronized (this) {
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + ":卖票，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowsTest2 {
    public static void main(String[] args) {
        Windows t1 = new Windows();
        Windows t2 = new Windows();
        Windows t3 = new Windows();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

1.4同步方法解决线程安全问题

class Windows4 extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}


public class WindowsTest4 {
    public static void main(String[] args) {
        Windows4 t1 = new Windows4();
        Windows4 t2 = new Windows4();
        Windows4 t3 = new Windows4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

2.实现Runnable接口

1.创建一个实现了Runnable接口的类?
2、实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象

4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
5.通过Thread类的对象调用start()

//1.创建一个实现了Runnable接口得类
class MThread implements Runnable{

    //2.实现类去实现Runnable中的抽象方法:run()
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread m1 = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(m1);
        //5.通过Thread类的对象调用start():①启动线程 ②调用当前线程的run() --> 调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(m1);
        t2.setName("线程2");
        t2.start();
    }
}

2.1同步代码块解决线程安全问题

class Dog{

}

class Windows1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();

    @Override
    public void run() {
        while(true){
            synchronized (this) {//此时的this:唯一的windows1的对象 //方式二:synchronized (dog) {
                if (ticket > 0) {

                    try{
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowsTest1 {
    public static void main(String[] args) {
        Windows1 w = new Windows1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

2.2同步方法解决线程安全问题

class Windows3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    public synchronized void show() { //同步监视器:this
//        synchronized (this){
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为: " + ticket);
            ticket--;
        }
//        }
    }
}

public class WindowsTest3 {
    public static void main(String[] args) {
        Windows3 w3 = new Windows3();

        Thread t1 = new Thread(w3);
        Thread t2 = new Thread(w3);
        Thread t3 = new Thread(w3);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

3.解决线程安全问题的方式三：Lock锁 --- JDK5.0新增

1.面试题：synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

Lock需要手动的启动同步( Lock() )，同时结束同步也需要手动的实现( unLock() )

注意：在使用lock方法前要进行声明定义，如下所示
private ReentrantLock lock = new ReentrantLock();

//关锁
lock.lock();

...

//开锁
lock.unlock();

4.比较创建线程方法：继承Thread方式和实现Runnable接口方式

开发中：优先选择：实现Runnable接口的方式：
原因：

1.实现的方式没有类的单继承性的局限性：
2.实现的方式更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

5.实现Callable接口(JDK5.0新增)

与使用Runnable相比，Callable功能更强大些
        相比run()方法，可以有返回值
        方法可以抛出异常
        支持泛型的返回值
        需要借助 FutureTask 类，比如获取返回结果

论如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

1. call()可以有返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable{

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

6.使用线程池(JDK5.0新增)

好处：
1.提高响应速度(减少了创建新线程的时间)
2.降低资源消耗(重复利用线程池中线程，不需要每次都创建)
3.便于线程管理
        corePoolSize ：核心池的大小
        maximumPoolSize ：最大线程数
        keepAliveTime ：线程没有任务时最多保持多长时间后会终止

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;


class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {

        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());  //适合适用于Runable
        service.execute(new NumberThread1());  //适合适用于Runable

//        service.submit(Callable callable);   //适合适用于Callable

        //3.关闭连接池
        service.shutdown();
    }
}

6.1线程池相关API

1.JDK5.0起提供了线程池相关API： ExecutorService 和Executors
2.ExecutorService :真正的线程池接口。常见子类 ThreadPoolExecutor
        》void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
        》<T>Future<T>submit(Callable<T>task)：执行任务，有返回值，一般又来执行Callable
        》void shutdown()：关闭连接池
3.Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
        》Executors. newCachedThreadPool ()：创建一个可根据需要创建新线程的线程池
        》Executors. newFixedThreadPool (n)；创建一个可重用固定线程数的线程池
        》Executors. newSingleThreadExecutor ()：创建一个只有一个线程的线程池
        》Executors. newScheduledThreadPool (n)：创建一个线程池，它可安排在给定延迟后过行命令或者定期地执行。

三、线程的生命周期

四、线程的死锁问题

1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2.说明：(1)出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续，(2)我们使用同步时，要避免出现死锁。

五、线程的通信

线程通信的例子：使用两个线程打印1-100。线程1，线程2交替打印，
涉及到的三个方法：
wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级。

notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。

说明：
1. wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
2. wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现 IllegalMonitorStateException 异常
3. wait()，notify()，not ifyAll()三个方法是定义在java. lang.Object

class Clerk{
    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if (productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    //消费产品
    public synchronized void consumeProduct() {
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":开始生产产品......");

        while (true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":开始消费产品......");

        while (true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 =new Producer(clerk);

        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);

        c1.setName("消费者1");

        p1.start();

        c1.start();
    }
}

面试题

Sleep()不释放锁给别的线程进行运行，而wait()会释放锁出来使得别的线程可以先运行。

最后

附上我的学习视频：尚硅谷Java入门视频教程(在线答疑+Java面试真题)

本文只是博主的一点点Java学习笔记，往后可能会继续更新，谢谢大家的浏览支持！

板牙叮咚

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE学习笔记(四)：多线程

目录背景以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？优点1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。2.提高计算机系统CPU的利用率3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改提示：以下是本篇文章正文内容，下面案例可供参考一、基本概念1.程序程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指...
复制链接

扫一扫