简单总结【java多线程机制】

最新推荐文章于 2022-10-25 13:02:55 发布

Mae_strive

最新推荐文章于 2022-10-25 13:02:55 发布

阅读量470

点赞数 3

分类专栏： javaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_51799151/article/details/119879464

版权

javaSE 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java多线程机制

一、多线程的创建

方式一：继承于Thread类

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

class MyThread extends Thread {

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

public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        //①启动当前线程;②调用当前线程的run()
        t1.start();
        //启动的还是主线程 只是对象调方法，所以不能通过run()方式启动线程
        //t1.run();
        //不能让已经start()的线程去执行
        //t1.start();
        //需重新创建一个线程对象
        MyThread t2=new MyThread();
        t2.start();
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

在这里插入图片描述

从图可以看出主线程、线程0和线程2 是并发进行的（强制）。

注意：这里必须调用Thread类中的start方法，而不是run方法

在这里插入图片描述
我们查看帮助文档中的start方法的介绍，start方法会启动一个新的线程，然后执行run方法，在新的线程上执行代码，实现多线程。如果调用run方法的话，那么代码还是在主线程上进行的，不能实现多线程。

那为什么调用start方法最终会调用run方法呢？
在这里插入图片描述

我们从源代码中可以看出，start方法中调用了start0方法，而start0方法中又调用了run方法。

方式二：实现Runnable接口

1、创建一个实现Runnable接口的类
2、实现类去实现Runnable中的抽象方法:run()
3、创建实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
5、通过此对象调用start()

package improve.threads.thread2;

//1、创建一个实现Runnable接口的类
class MyThread implements Runnable {
    //2、实现类去实现Runnable中的抽象方法:run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MyThread myThread = new MyThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
        Thread t1 = new Thread(myThread);
        //5、通过此对象调用start() -->通过Runnable类型的target的run()
        Thread t2 = new Thread(myThread);
        //开启线程
        t2.start();
        t1.start();
        t1.setName("线程一");
        t2.setName("线程二");
    }
}

方式三、实现Callable接口

实现Callable接口的好处（相较于实现Ruunable接口）

可以有返回值
方法可以抛出异常
支持泛型的返回值
借助FutrueTask类获取返回值结果

package improve.threads.Thread7;

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

/**
 * @author: Mae.W
 */

class MyThread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);
        Thread thread = new Thread(futureTask);  //创建Thread类对象，将FutureTask类的对象传到 此对象的构造器中 （FutureTask也实现Runnable接口）
        //启动线程
        thread.start();
        try {
        //如果不需要返回值则此处课省略
            Object obj = futureTask.get();  //get方法的返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
            System.out.println("sum="+obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四、线程池创建多线程

实际开发中一般都是使用线程池创建多线程
优点：

1、提高相应速度
2、降低资源消耗
3、便于线程管理

属性：
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间会终止

 package improve.threads.threadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author: Mae.W
 *
 * 使用线程池创建线程
 */
class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i >-100 ; i--) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1、提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //2、执行指定的线程的操作，需要提供实现Runnable接口/Callable接口实现类的对象
        executorService.execute(new NumberThread());//适合使用于Runnable
        executorService.execute(new NumberThread());//适合使用于Runnable
        executorService.execute(new NumberThread1());//适合使用于Runnable
        executorService.shutdown();//关闭

/*        executorService.submit();//适合使用于Callable*/
    }
}

二、多线程的安全问题

共享受限资源

在多线程中，如果两个线程同时使用同一个资源，那么有可能会产生线程安全问题。
例如

//1、创建一个实现Runnable接口的类
class MyThread implements Runnable {
    private int num = 10;
    //2、实现类去实现Runnable中的抽象方法:run()
    @Override
    public void run() {
        while (true) {
             {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num--;
                } else {
                    break;
                }
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MyThread myThread = new MyThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
        Thread t1 = new Thread(myThread);
        //5、通过此对象调用start() -->通过Runnable类型的target的run()
        Thread t2 = new Thread(myThread);
        t1.start();
        t2.start();
       t1.setName("线程一");
       t2.setName("线程二");

    }
}

在此例中，线程一和二共享同一个资源->num，那么此线程就不安全

运行结果：

在这里插入图片描述

我们发现输出语句最后输出了0，而程序代码中 num<=0 就会结束。为什么还会出现0呢？

假设num=1后线程1进入if语句，但就在此时num还没有减1，所以线程2也进入了if语句之后num-1 线程2就输出了0

我们还发现输出中有重数，主要是因为我们一个线程满足条件进入了if语句，输出了num，还没有来得及减1，另外一个线程也进入if语句，输出了同样的数。

如何解决线程安全问题呢？

三、解决线程安全问题

1、同步代码块

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

说明：操作共享数据的代码，即为需要同步的代码
共享数据：多个线程共同操作的变量
同步监视器：俗称，锁；任何一个类的对象都可以充当
要求：多个线程必须要共用同一把锁
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
局限性：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低

class MyThread implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            //this 唯一 是MyThread类的对象 myThread
            synchronized (this) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票：票号" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }

        }
    }
}

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

        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述
可以看出线程安全问题解决了，要特别注意共用同一把锁，否则不起作用

2、同步方法

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

        }
    }

错误示例！ 我们不能将run方法设置为同步的，因为while循环不是同步数据。
改进：

class MyThread implements Runnable {
    private int ticket = 100;

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

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

将同步语句if写在show方法中，将show方法设置为同步方法

同步方法总结：

非静态的同步方法，同步监视器是this

死锁问题：1、不同的线程分别占用对方所需要的同步资源不放弃，都在等待对方放弃自己所需要的同步资源，形成了线程的死锁
2、出现死锁情况，不会抛异常，也不会出现提示，所以线程都进入阻塞状态，无法继续执行

3、lock锁

class MyThread implements Runnable {
    private int ticket = 1000;
    //1、实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //调用锁定方法lock();
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                //调用解锁方法unlock()
              lock.unlock();
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        t1.start();
        t2.start();
        t3.start();
    }
}

4、synchronized与lock的异同

同：二者都可以解决线程安全问题
不同：synchronized执行完相应的同步代码后，自动地释放同步监视器
lock需要手动启动同步(lock方法)和结束同步(unlock方法)

建议优先使用顺序：lock->同步代码块->同步方法

四、线程通信

线程通信：
例：交替打印

方法：
wait():一旦进入此方法，当前线程就会进入阻塞状态，并释放同步监视器
notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，则唤醒优先级高的线程，若优先级相同则随机唤醒一个
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
说明：
1、这三个方法必须在同步代码块或者同步方法中
2、这三个方法的调用者必须是同步代码块或同步方法中的同步监视器
3、这三个方法定义在Object类中

class MyThread implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            //this 唯一 是MyThread类的对象 myThread
            synchronized (this) {
                //唤醒阻塞的所有线程
                notifyAll();
                if (ticket > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票：票号" + ticket);
                    ticket--;
                    try {
                        //让当前线程阻塞
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }

        }
    }
}

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

        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

sleep()和wait()异同

同：一旦方法执行，都可以使得当前线程进入阻塞状态
异：

（1）两个方法声明位置不同。Thread类声明sleep()；Object类声明wait()；
（2）调用范围不同。sleep()可以在任何需要的场景下调用；wait()必须写在同步代码块或者同步方法中
（3）关于是否释放同步监视器。如果两个方法都写在同步代码块或者同步方法中，sleep()不释放同步监视器(锁)，wait()会释放同步监视器(锁)

Mae_strive

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
简单总结【java多线程机制】

简单总结一下java多线程机制一、多线程的创建方式一：继承于Thread类1、创建一个类继承于Thread类2、重写Thread类的run()–>此线程执行的操作声明在run()中3、创建Thread类子类的对象4、通过此对象去调用start()class MyThread extends Thread { @Override public void run() { for (int i = 0; i < 100; i++) {
复制链接

扫一扫