Java多线程

最新推荐文章于 2024-04-15 07:20:58 发布

不想再掉头发了.

最新推荐文章于 2024-04-15 07:20:58 发布

阅读量434

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_51296701/article/details/123698780

版权

一、多线程的基本概念

进程和线程：

程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象
进程: 进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存
线程: 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行。进程要想执行任务，必须得有线程，进程至少要有一条线程。程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程

进程和线程的区别：

同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间；
同一进程内的线程共享本进程的资源，而进程间的资源是独立的

单线程和多线程：

单线程: 一个进程如果只有一条执行路径,就叫单线程程序
多线程: 一个进程如果有多条执行路径,叫做多线程程序

二、实现多线程

Java提供了很多方法实现多线程：

1.继承Thread类

定义一个类MyThread继承Thread类·

   public class MyThread extends Thread {

在MyThread类中重写run()方法

public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i); //线程中执行打印1到100
        }

创建MyThread类的对象·

首先介绍一下设置和获取线程名称Thread类中设置和获取线程名称的方法
void setName(String name):将此线程的名称更改为等于参数name
String getName():返回此线程的名称
通过构造方法也可以设置线程名称
要让线程加上名字，需在MyThread类中定义无参构造和带参构造，所以MyThread类应为：

public class MyThread extends Thread {
    public  MyThread(){};
    public MyThread(String name){
        super(name);  
    }

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

在测试类中：

        //无参构造
//        MyThread myThread1=new MyThread();
//        MyThread myThread2=new MyThread();
//          myThread1.setName("线程1");
//          myThread2.setName("线程2");

        //带参构造
        MyThread myThread1 = new MyThread("线程1");
        MyThread myThread2 = new MyThread("线程2");

启动线程

void start() 使此线程开始执行,JVM调用此线程的run方法

        myThread1.start();
        myThread2.start();

完成上述操作后运行就可以看到这两个线程同时启动：
在这里插入图片描述

这样我们就利用Thread简单的实现了多线程，但是这里有两个小问题:
为什么要重写run()方法?
因为run()是用来封装被线程执行的代码(要做的功能)
run()方法和start()方法的区别?
run():封装线程执行的代码，直接调用，相当于普通方法的调用
start():启动线程;然后由JVM调用此线程的run()方法

最后说一下如何获取main(）方法所在的线程名称?
public static Thread currentThread():返回对当前正在执行的线程对象的引用

 System.out.println(Thread.currentThread().getName());

运行就会看到线程的名字了
在这里插入图片描述

2.实现Runnable接口

定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i); //获取当前线程名字和i
        }
    }
}

创建MyRunnable类的对象`
创建Thread类的对象，把MyRunnable对象作为构造方法的参数

   //创建MyRunnable类的对象
        MyRunnable mr=new MyRunnable();

        //创建Thread类的对象,把Runnable对象作为构造方法的参数
        //Thread(Runnable target)
        //Thread(Runnable target,String name)
        Thread thread1=new Thread(mr,"大哥");
        Thread thread2=new Thread(mr,"二弟");

        thread1.start();
        thread2.start();

启动线程

        thread1.start();
        thread2.start();

最终也可以看到：
在这里插入图片描述

相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好子的体现了面向对象的设计思想

三、线程优先级

前面在控制台看到二弟总在大哥的前面，如果想让大哥尽可能在二弟前面如何实现？

线程调度

线程有两种调度模型

分时调度模型:所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
抢占式调度模型:优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些

Java使用的是抢占式调度模型
假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的。

Thread类中设置和获取线程优先级的方法

public final int getPriority():返回此线程的优先级
public final void setPriority(int newPriority):更改此线程的优先级

线程默认优先级是5; 线程优先级的范围是:1-10
线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

举个栗子
老虎、龟和兔子进行百米赛跑,显然老虎的速度是最快的,其次是兔子和龟。这里我们就需要设置优先级

   public static void main(String[] args) {
        ThreadPriority myThread1 = new ThreadPriority("老虎");
        ThreadPriority myThread2 = new ThreadPriority("龟");
        ThreadPriority myThread3 = new ThreadPriority("兔子");
        //设置优先级
        myThread1.setPriority(10);
        myThread2.setPriority(1);
        myThread3.setPriority(5);
        //启动线程
        myThread1.start();
        myThread2.start();
        myThread3.start();

    }

运行几次后看结果:
在这里插入图片描述
在老虎跑了13米兔子才开始,而龟开始的时候,老虎已经走了58米。
这样我们就对线程设置了优先级，但是还要强调一下线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

四、线程控制

下面介绍几个常用的方法:

sleep

static void sleep(long mills) 使当前执行的线程停留指定秒数

   @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" "+i);
            try {
                Thread.sleep(1000);    //每次执行后停留一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

这样线程的资源分配就是均匀的了,因为每次执行后都停留1000毫秒,但是不同线程还是会抢执行权,所以同一个资源下,不同线程的顺序也是不确定的。
在这里插入图片描述

join

如果想让一个线程跑完再进行其他线程，比如先让大哥先走，二弟和三弟再强执行权。
就要用到join
void join() 等待这个线程死亡

        tj1.start();
        tj1.join();    //让大哥先走..大哥走了,二弟三弟才开始抢
        tj2.start();
        tj3.start();

在这里插入图片描述
可以看到，大哥全部执行完毕后，二弟和三弟才开始抢执行权。

Daemon

void setDaemon(boolean on) 将此线程标记为守护线程,当所有线程都是守护线程,JVM退出
意思就是，用setDaemon()会将线程标记为守护线程，去守护一个主线程。主线程结束后，守护线程也即将结束

    public static void main(String[] args) {

        ThreadDaemon td1 = new ThreadDaemon("二弟");
        ThreadDaemon td2 = new ThreadDaemon("三弟");

        //设置主线程是大哥
        Thread.currentThread().setName("大哥");

       //设置守护线程,,二弟三弟保护 大哥(主线程)
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

效果如下：
在这里插入图片描述

五、线程的生命周期

JDK中用Thread.State类定义了线程的几种状态，如下：

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

六、线程同步

案例

需求:某电影院目前正在上映电影，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
思路:
定义一个类SelTicket实现Runnable接口，里面定义一个成员变量: private int tickets = 100;
在SellTicket类中重写run()方法实现卖票，代码步骤如下
A:判断票数大于0，就卖票，并告知是哪个窗口卖的B:卖了票之后，总票数要减1
C:票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
A:创建SellTicket类的对象
B:创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
按照上面的思路实现:

public class SellTicket implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if(tickets>0){
                try {
                    Thread.sleep(100); 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在售出第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();

        Thread thread1=new Thread(st,"窗口一");
        Thread thread2=new Thread(st,"窗口二");
        Thread thread3=new Thread(st,"窗口三");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

可以看到运行结果完全不符合逻辑:
在这里插入图片描述

可以看到出现了问题
1相同的票出现了多次
2出现了负数得票
为什么会这样嘞,原因是 线程执行的随机性
在run()方法中分析:

 @Override
    public void run() {

        while (true) {
            //假设t1抢到执行权
            if(tickets>0){
                try {
                    Thread.sleep(100); //t1线程睡了100ms    t2线程抢到了线程执行权开始执行,执行到这里也睡100ms t3...
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按顺序醒过来 t1抢到执行权输出,,t2,,t3...
                System.out.println(Thread.currentThread().getName()+"正在售出第"+tickets+"张票");
                tickets--;
                //如果线程还按照顺序,就执行了三次--,所以会出现三次一样的问题

                //执行权和循环判断条件启冲突了,停止条件在循环结束前,被其他线程使用了
                //线程是在票还没到0的时候进入了if,在进入if后,票被其他线程减了,所以产生了负数
                //也就是说在线程1休息的时候,其他线程进入了if中,把票--了
            }

        }
    }

如何解决数据安全问题

卖票案例数据安全问题的解决
为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)
●是否是多线程环境
●是否有共享数据
●是否有多条语句操作共享数据

如何解决多线程安全问题呢?
基本思想:让程序没有安全问题的环境

怎么实现呢?
把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现格式:
synchronized(任意对象){
多条语句操作共享数据的代码
}
synchronized(任意对象):就相当于给代码加锁了，任意对象就可以看成是一把锁

实现:

public class SellTicket implements Runnable {
    private int ticket = 100;
    private Object obj = new Object();  //任意对象可以看成是一把锁

    @Override
    public void run() {
        //线程t1进入代码块后上锁,其他线程进不去
            while (true) {
                synchronized (obj) {   //synchronized(任意对象):就相当于给代码加锁了
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在售出第" + ticket + "张票");
                    ticket--;
                } 
            }  //线程结束锁会被释放
        }
    }
}

这样就可以看到票一张一张的被售空了
在这里插入图片描述
…

同步方法

同步方法:就是把synchronized关键字加到方法上
格式:
修饰符synchronized返回值类型方法名(方法参数){}
同步方法的锁对象是什么呢?
this 即synchronized(this){}

public class SellTicket implements Runnable {
    private int ticket = 100;
//    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (x % 2 == 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在售出第" + ticket + "张票");
                        ticket--;
                    }
                } else {
                    sellTicket();  //同步方法
                }
                x++;
            }
        }
    }
    public synchronized void sellTicket() {   //对方法里的代码加上锁
            if (x % 2 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在售出第" + ticket + "张票");
                    ticket--;
                }
            }
        }
}

同步静态方法

同步静态方法:就是把synchronized关键字加到静态方法上
格式:
修饰符static synchronized返回值类型方法名(方法参数{}
同步静态方法的锁对象是什么呢
类名.class 即synchronized(类名.class)

public class SellTicket implements Runnable {
    private static int ticket = 100;
//    private Object obj = new Object();
    private static int x = 0;

    @Override
    public void run() {
        while (true) {
            synchronized (SellTicket.class) {   //得到该类字节码文件对象
                if (x % 2 == 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在售出第" + ticket + "张票");
                        ticket--;
                    }
                } else {
                    sellTicket();  //同步静态方法
                }
                x++;
            }
        }
    }
        public static synchronized void sellTicket() {   //静态方法
            if (x % 2 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在售出第" + ticket + "张票");
                    ticket--;
                }
            }
        }
}

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作Lock中提供了获得锁和释放锁的方法
void lock():获得锁
void unlock():释放锁
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化ReentrantLock的构造方法
ReentrantLock():创建一个ReentrantLock的实例
private Lock lock=new ReentrantLock


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock=new ReentrantLock();  //创建一个锁,并实例化
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在售出第"+tickets+"张票");
                    tickets--;
                }
            }
            finally {
                lock.unlock();    //try finally防止线程出问题时锁不会被释放
            }
        }
    }
}

七、生产者和消费者案例

生产者消费者模式

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻所谓生产者消费者问题，实际上主要是包含了两类线程;

一类是生产者线程用于生产数据
一类是消费者线程用于消费数据
为了解耦生产者和消袭者的关系，通常会采用共享的数据区域，就像是一个仓库
·生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
·消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
生产者---->共享数据域<----消费者

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中Object类的等待和唤醒方法:

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的notify方法或notifyAll方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤酵正在等待对象监视器的所有线程

案例

生产者消费者案例中包含的类:
奶箱类(Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
消费者类(Customer):实现Runnable接口。重写run0方法。调用获取牛奶的操作
测试类(BoxDemo):里面有main方法，main方法中的代码步骤如下
1创建奶箱对象，这是共享数据区域
2创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
3创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
4创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
5启动线程

创建共享数据域

public class Box {
    //奶箱状态
    private boolean state = false;
    private int milk;
    //提供存储牛奶和获取牛奶的操作
    public synchronized void set(int milk) {
        if (state) {
            try {
                wait(); //如果有牛奶,等待消费
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没有牛奶,就生产
        this.milk = milk;
        System.out.println("送奶工人将第" + this.milk + "瓶奶放入箱中");
        state = true;  //修改奶箱状态
        //唤醒其他等待线程
        notifyAll();
    }

    public synchronized void get() {
        //如果没有牛奶,等待生产
        if (!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

       //如果有牛奶,就将其消费
        System.out.println("用户拿到第" + this.milk + "瓶奶");
        //修改奶箱状态
        state=false;
        notifyAll();
    }
}

创建生产者和消费者

public class Producer implements Runnable{
    private Box b;
    public Producer(Box b) {
        this.b=b;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
           b.set(i);
        }
    }
}

public class Customer implements Runnable {
    Box b = new Box();
    public Customer(Box b) {
        this.b = b;
    }
    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

创建并启动线程

public class Demo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b=new Box();
       // 创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p=new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c=new Customer(b);
      //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}

在这里插入图片描述
以上就是关于多线程的基础知识,欢迎大佬补充和改正。

不想再掉头发了.

关注

0
点赞
踩
2

收藏

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

一、多线程的基本概念进程和线程：程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象进程: 进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存线程: 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行。进程要想执行任务，必须得有线程，进程至少要有一条线程。程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程进程和线程的区别：同一进程的线程共享本进程的地址空间，而进程之间则是独
复制链接

扫一扫