Java多线程

最新推荐文章于 2024-03-20 10:15:00 发布

m0_56348008

最新推荐文章于 2024-03-20 10:15:00 发布

阅读量50

点赞数

本文链接：https://blog.csdn.net/m0_56348008/article/details/119331134

版权

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

**进程(process)**是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 >如：运行中的QQ，运行中的MP3播放器 >程序是静态的，进程是动态的 >进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

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

并行与并发 > 并行：多个CPU同时执行多个任务。比如：每个同学各拿一个练习 > 并发：一个CPU(采用时间片)同时执行多个任务。比如：一个篮球队一起玩一个篮球

创建多线程两种方式

方式一：继承Thread类

1. 创建一个继承于Thread类的子类
1. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
1. 创建Thread类的子类的对象
1. 通过此对象调用start():①启动当前线程 ② 调用当前线程的run()

体会1：不能通过直接调用run( )的方式启动线程
体会2：不可以让已经start( )的线程去执行，会报IllegalThreadStateException；我们需要重创建一个线程的对象。

在这里插入图片描述

Thread类的匿名子类

//匿名子类可以通过重写类方法，减少创造多个子类
public class ThreadTest{
    public static void main(String[] args) {
		//重写Thread类的run()方法
        new Thread("线程一："){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
        
        new Thread("线程二："){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
    }
}

方式二：实现Runnable接口

创建一个实现了Runnable接口的类

实现类去实现Runnable中的抽象方法：run()

创建实现类的对象

将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

通过Thread类的对象调用start()：① 启动线程 ②调用当前线程的run()–>调用了Runnable类型的target的run()

注意：由于是多个线程共用一个对象，此时多个线程共享数据不加static也行

比较创建线程的两种方式。
- 开发中：优先选择：实现Runnable接口的方式
- 原因：
  - 1. 实现的方式没有类的单继承性的局限性，可以实现多个接口
  - 2.实现的方式更适合来处理多个线程有共享数据的情况。
- 联系：Thread类本身也是实现了Runnable接口
- 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

class MThread implements Runnable{
    //由于是多个线程共用一个对象，此时多个线程共享数据不加static也行
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while(true){
            synchronized (obj){
                if (ticket > 0){                   System.out.println(Thread.currentThread().getName()+":卖票，票号"+ticket);

                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
//只创建一个实现类的对象，将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
        MThread m = new MThread();
        Thread t1 = new Thread(m);
        t1.setName("窗口一");
        t1.start();

        Thread t2 = new Thread(m);
        t2.setName("窗口二");
        t2.start();

        Thread t3 = new Thread(m);
        t3.setName("窗口三");
        t3.start();

    }
}

方式三：实现Callable接口(JDK5.0)

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
1. call()可以有返回值的。
1. call()可以抛出异常，被外面的操作捕获，获取异常的信息
Callable是支持泛型的

Future接口

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

//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();
        }
    }
}

方式四：使用线程池

好处：

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

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; //强转，因为接口属性少
//ThreadPoolExecutor extends AbstractExecutorService --> AbstractExecutorService implements ExecutorService
        //设置线程池的属性
//System.out.println(service.getClass()); ThreadPoolExecutor
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

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

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown(); } }

Thread类有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
**void setName(String name)😗*设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
**static void yield()：**线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
**join() ：**当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒) 1000ms —> 1s
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常

线性的调度

抢占式策略：高优先级的线程抢占CPU

1、Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略
2、线程的优先级等级（优先级高的线程先执行的概率高，但不是一定优先执行）
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5 ---->默认优先级
3、获取和设置当前线程优先级
- getPriority()
- setPriority(int newPriority) //在start前修改

线程的生命周期

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

在这里插入图片描述

线程的同步

线程的安全问题

问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

在java中我们通过同步机制，来解决线程安全问题。

方式一：同步代码块

synchronized(同步监视器){
	//需要被监视的代码
}

1.说明：操作共享数据的代码，即为需要被同步的代码
2.共享数据：多个线程共同操作的变量
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须共用同一把锁：对象必须声明在run()方法外面
4.同步代码，不能包多了，否则可能变成一个线程拿到锁后开始执行任务直到任务结束，变成了单线程。等等多种情况；也不能包少了造成线程安全问题

好处：解决的线程安全问题
缺陷：在同步代码块外面是多线程，但在同步代码块里面，实际上只能同时有一个线程在执行，相当于是一个单线程过程

①使用同步代码块解决–>继承Thread类线程安全问题

class MThread extends Thread{
    private static int ticket = 100;
    private static Object obj = new Object();
 //继承和实现类不同，每一个子类对象都有单独的锁，所以必须加static
    //this代表t1、t2、t3三个对象，不唯一
    @Override
    public void run() {
        while (true){
            synchronized (obj){
 //synchronized(MThread.class) //MThread.class:类也是对象，     MThread.class类只加载一次
                if (ticket > 0){
                    System.out.println(currentThread().getName()+":卖票，票号"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

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

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

②使用同步代码块解决 -->实现接口类线程安全问题

class MThread implements Runnable{
    private int ticket = 100;
    //this代表当前实现类对象m1，是唯一的
    @Override
    public void run() {
   //如果声明对象在run()方法里面，则有几个线程就有几把锁，线程不安全
        while(true){
            synchronized (this){
                if (ticket > 0){             System.out.println(Thread.currentThread().getName()+":卖票，票号"+ticket);

                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MThread m1 = new MThread();
        //天然的形成共享，因此不用加static
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m1);
		Thread t3 = new Thread(m1);
        
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

关于同步方法的总结：
1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
1. 非静态的同步方法，同步监视器是：this
1. 静态的同步方法，同步监视器是：当前类本身

①同步方法解决–>继承Thread类线程安全问题

class MThread extends Thread{
    private static int ticket = 100;
    @Override
    public void run() {
        while (true){ //单独建show()类为了避免同步代码多包问题
            show();
        }
    }

    public static synchronized void show(){ 
        //有锁 同步监视器：MThread.class 是当前类（唯一）
        if (ticket > 0){
         System.out.println(Thread.currentThread().getName()+":卖票，票号"+ticket);
            ticket--;
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MThread t1 = new MThread();
        MThread t2 = new MThread();
        MThread t3 = new MThread();

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

②同步方法解决 -->实现Runnable接口线程安全问题

class MThread implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            show();
        }
    }
    public synchronized void show(){ 
        //有锁，同步监视器是：this 当前类对象（唯一）
        if (ticket > 0){
         System.out.println(Thread.currentThread().getName()+":卖票，票号"+ticket);
            ticket--;
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MThread m1 = new MThread();
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m1);
        Thread t3 = new Thread(m1);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

(单例)懒汉式线程安全问题

public class BankTest {
    public static void main(String[] args) {
        Bank b1 = Bank.getInstance();
        Bank b2 = Bank.getInstance();
        System.out.println(b1 == b2);
    }
}

class Bank{
    private Bank(){
    }
    private static Bank instance = null;

    public static Bank getInstance(){
     //加if后，如果第一个线程已经进去，那么后面的线程就无需排队，直接返回instance
        if (instance == null) {
            synchronized (Bank.class){ //同步监视器 ：Bank.class
                if (instance == null){
                    instance = new Bank();
                }
                return instance;
            }
        }
        return instance;
    }
}

线程的死锁问题

1. 死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
1. 说明：
- 1）出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
- 2）我们使用同步时，要避免出现死锁。
1. 解决方法：
- 专门的算法、原则规避死锁
- 减少同步资源的定义
- 尽量避免嵌套同步

线程的通信

线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
涉及到的三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
说明：
1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
否则，会出现IllegalMonitorStateException异常
3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
面试题：sleep() 和 wait()的异同？
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

class Number implements Runnable{
    private int number = 1;
    private Object obj = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj) {
                obj.notify();
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
           //使得调用如下wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

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

例题：生产者消费者问题(线程通信)

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 Productor extends Thread{
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+"开始生产......");
        while (true){
            clerk.produceProduct();
        }
    }
}
class Customer extends Thread{
    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(getName()+"开始消费......");
        while (true){
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Productor p1 = new Productor(clerk);
        p1.setName("生产者1");

        Customer c1 = new Customer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }
}

m0_56348008

关注

0
点赞
踩
0

收藏

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

**程序(program)**是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。**进程(process)**是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 >如：运行中的QQ，运行中的MP3播放器 >程序是静态的，进.
复制链接

扫一扫