4.26-4.27多线程学习笔记

最新推荐文章于 2024-09-25 10:59:43 发布

RXHCX

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量119

点赞数

文章标签： java 多线程并发编程 thread

本文链接：https://blog.csdn.net/RXHCX/article/details/116196512

版权

4.26-4.27多线程的学习笔记

文章目录

- 4.26-4.27多线程的学习笔记

多线程

1.线程是独立的执行路径

2.进程包含线程，可能执行一个进程，内部有多个线程在同时执行。

3.在一个进程中，如果开辟多个线程，线程的运行由调度器安排调度，调度器与操作系统紧密相关的，先后顺序是不能人为干预的，

4.每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

5.真是意义上的多线程是多个cpu同时执行，及多核如服务器等，模拟的多线程还是单线程因为cpu的调用速度快。

继承Thread类

package cx.javathread;

/**
 * @ClassName thread1
 * Description 继承Thread类实现线程
 * Author CX
 * Date 2021/4/26 10:09
 */
public class thread1 extends Thread{
    @Override
    public void run() {   //重写run方法
        for (int i = 0; i < 20; i++) {
            System.out.println("这是第一个继承thread类"+i);
        }
    }

    public static void main(String[] args) {
        thread1 t1=new thread1();//实例化thread对象
        t1.start();//通过start方法启动线程
        for (int i = 0; i < 200; i++) {
            System.out.println("这里是主线程"+i);
        }
    }
}

实现Runnable接口

package cx.javathread;

/**
 * @ClassName RunnableThread
 * Description TOOD
 * Author CX
 * Date 2021/4/26 10:13
 */
public class RunnableThread implements Runnable{

    @Override
    public void run() {
        //重写runnable的run方法
        for (int i = 0; i < 20; i++) {

            System.out.println("这里是runnable线程的run方法"+i);
        }
    }

    public static void main(String[] args) {
        RunnableThread r1=new RunnableThread();
        Thread t1=new Thread(r1);
        t1.start();
        for (int i = 0; i < 300; i++) {
            System.out.println("这里是主线程"+i);
        }
    }
}

通过龟兔赛跑实现多线程

package cx.javathread;

/**
 * @ClassName Race
 * Description 模拟龟兔赛跑
 * Author CX
 * Date 2021/4/26 10:45
 */
public class Race implements Runnable{

   public static String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {

            try {
                if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
                    Thread.sleep(1);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean flag=gameover(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName() + "----跑了" + i + "步");
        }
    }
    //判断游戏结束的方法
        public boolean gameover(int i){
            if (winner != null) {
                return true;
            }if (i==100){
                winner=Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
            return false;
        }

    public static void main(String[] args) {
        Race race=new Race();
        Thread t1=new Thread(race,"兔子");
        Thread t2=new Thread(race,"乌龟");
        t1.start();
        t2.start();
    }

}

实现Callable接口

package cx.javathread;

import java.util.concurrent.*;

/**
 * @ClassName CallableThread
 * Description 实现Callable接口
 * Author CX
 * Date 2021/4/26 14:54
 */
public class CallableThread implements Callable<Boolean>{
    @Override
    public Boolean call() throws Exception {
        //重写Callable的call方法
        for (int i = 0; i < 20; i++) {
            System.out.println("这里是Callable线程的call方法"+i);
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableThread call=new CallableThread();//实例化Callable对象
        //打开Callable线程，指定线程的数量nThreads
        ExecutorService ser= Executors.newFixedThreadPool(1);
        //提交线程call
        Future<Boolean> r1= ser.submit(call);

        //获取结果
        boolean b1=r1.get();
        //关闭线程
        ser.shutdownNow();
    }
}

Lamda表达式

函数式接口：

任何接口如果只有一个抽象方法，那么它就是一个函数式接口，对于函数式接口，我们可以通过lamda表达式来创建该接口的对象。

总结：1.只有当接口是抽象函数式接口时可以使用lamda表达式、

2.去掉括号,当参数只有一个是可以去掉括号（）。

3.去掉花括号,当内部只有一条Java语句可以去掉花括号{}

package cx.javathread;

/**
 * @ClassName JavaLamda
 * Description 实现lamda简化操作
 * Author CX
 * Date 2021/4/26 16:47
 */
public class JavaLamda {
    public static void main(String[] args) {
        //lambda简化操作
        love l=new love() {
            @Override
            public void lambda(int i) {
                System.out.println("这是匿名内部类"+i);
            }
        };
        l.lambda(520);

        //lamda表达式
        love l2=(int a)->{
            System.out.println("这是lamda表达式的运用"+a);
        };
        l2.lambda(521);

        //lamda简化一，去掉返回类型
        love l3=(a)->{
            System.out.println("这是lamda表达式的简化一"+a);
        };
        l3.lambda(522);

        //lamda简化二，去掉括号,当参数只有一个是可以去掉括号（）。
        love l4=a->{
            System.out.println("这是lamda表达式的简化二"+a);
        };
        l4.lambda(523);

        //lamda简化三，去掉花括号,当内部只有一条Java语句可以去掉花括号{}。
        love l5=a->
            System.out.println("这是lamda表达式的简化三"+a);
        l5.lambda(524);



    }

    interface love {
        public void lambda(int i);

    }
}

线程的状态

在这里插入图片描述

线程的终止

不建议使用stop或者destroy方法。建议线程正常停止或者使用标志位。

线程的休眠

sleeep（时间）指定当前线程阻塞的毫秒数；

sleep存在异常InterruptedException；

sleep时间达到后线程进入就绪状态

sleep可以模拟网络延时，倒计时等；

每一个对象都有一个锁，sleep不会释放锁；

可以放大问题的发生性

线程礼让

线程礼让，让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让cpu重新调度，礼让不一定成功，看cpu心情

package cx.javathread;

/**
 * @ClassName ThreadJoin
 * Description TOOD
 * Author CX
 * Date 2021/4/26 19:16
 */
public class ThreadJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 400; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoin j=new ThreadJoin();
        Thread t=new Thread(j);
        t.start();
        for (int i = 0; i < 300; i++) {
            if (i==200){
                t.join();
            }
            System.out.println("main"+i);

        }
    }
}

线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。线程的优先级越高不一定先执行，也要看cpu的调度，但是优先级越高那么权重也会越大。

线程的优先级用数字表示，范围从1-10.

Thread.MIN_PRIORTY=1;

Thread.MAX_PRIORTY=10;

Thread.NORM_PRIORTY=5;

使用以下方式可以该表线程的优先级

getPrority().setPriority(int XXX);

package cx.javathread;

/**
 * @ClassName ThtreadProity
 * Description 测试线程的优先级
 * Author CX
 * Date 2021/4/26 19:33
 */
public class ThtreadProity {
    public static void main(String[] args) {

        MyProity m=new MyProity();
        Thread t1=new Thread(m);
        Thread t2=new Thread(m);
        Thread t3=new Thread(m);
        Thread t4=new Thread(m);

        t1.start();

        t2.setPriority(1);
        t2.start();
        t3.setPriority(5);
        t3.start();
        t4.setPriority(10);
        t4.start();
    }
}
class MyProity implements Runnable{


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---"+Thread.currentThread().getPriority());
    }
}

守护线程

线程分为用户线程和守护线程

虚拟机必须确保用户线程执行完毕

虚拟机不用等待守护线程执行完毕

package cx.javathread;

/**
 * @ClassName ShouhuThread
 * Description 测试守护线程
 * Author CX
 * Date 2021/4/26 19:44
 */
public class ShouhuThread {
    public static void main(String[] args) {

        God god=new God();
        you you=new you();
        Thread t1=new Thread(god);
        t1.setDaemon(true);//设置为守护线程。默认是false，为false时为用户线程，为true时 为守护线程
        t1.start();
        new Thread(you).start();//用户线程启动
    }
}
class God implements  Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护这你");
        }
    }
}

//用户线程
class you implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("开心的活着");
        }
        System.out.println("goodbye！");
    }
}

线程同步机制：

ArrayList是不安全的，可能是两个线程同时操作到一个数据，就覆盖掉了，所以数量会变少

synchroized锁方法默认锁的本对象

package cx.javathread;

/**
 * @ClassName UnsafeBuyTicket
 * Description 不安全的买票,有人拿到相同的票或者负数。使用synchronized锁住run方法
 * Author CX
 * Date 2021/4/26 20:03
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buy=new BuyTicket();
        new  Thread(buy,"小明").start();
        new  Thread(buy,"小红").start();
        new  Thread(buy,"小华").start();
    }
}
class BuyTicket implements Runnable{

    private int ticketNums = 10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            buy();
        }

    }
    public synchronized   void  buy(){  //加锁让线程排队，拿到锁的线程先运行，没有拿到的等待
        //判断是否有票
        if (ticketNums<=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //输出买票人
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

synchroized(object){} sychroized同步块锁变化的量，需要增删改的对象

package cx.javathread;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName UnsafeList
 * Description 使用synchronized同步块锁住List的对象。
 * Author CX
 * Date 2021/4/27 9:16
 */
public class UnsafeList {
    public static void main(String[] args) {
        List l=new ArrayList();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                synchronized (l) {
                    l.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        System.out.println(l.size());
    }
}

死锁

多线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有两个以上对象的锁时，就可能发生死锁。

案例：

package cx.javathread;

/**
 * @ClassName DeadLock
 * Description 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * Author CX
 * Date 2021/4/27 9:31
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"小明");
        Makeup g2=new Makeup(1,"小红");
        g1.start();
        g2.start();
    }

}
class  Lipatick{

}
class mirror{

}
class Makeup extends Thread{
    //需要的资源只有一份，通过static保证只有一份
    static Lipatick lipatick=new Lipatick();
    static  mirror m=new mirror();

    int choice;//选择
    String girlname;//使用化妆品的人
    Makeup(    int choice, String girlname){
        this.choice=choice;
        this.girlname=getName();

    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //互相持有对方的锁，需要拿到对方的锁
    public void makeup()throws InterruptedException{
        if (choice==0){
            synchronized (lipatick){
                System.out.println(this.girlname+"获得口红的锁");
                    Thread.sleep(1000);//一秒钟之后想获得镜子的锁
                synchronized (m){
                    System.out.println(this.girlname+"获得镜子的锁");
                }
            }

            }else {
            synchronized (m){
                System.out.println(this.girlname+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipatick){
                    System.out.println(this.girlname+"获得口红的锁");

                }
            }

        }
    }
}

修改方法：把同步块中的代码锁拿出来，避免同步代码块有两个或以上的锁。

package cx.javathread;

/**
 * @ClassName DeadLock
 * Description 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * Author CX
 * Date 2021/4/27 9:31
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"小明");
        Makeup g2=new Makeup(1,"小红");
        g1.start();
        g2.start();
    }

}
class  Lipatick{

}
class mirror{

}
class Makeup extends Thread{
    //需要的资源只有一份，通过static保证只有一份
    static Lipatick lipatick=new Lipatick();
    static  mirror m=new mirror();

    int choice;//选择
    String girlname;//使用化妆品的人
    Makeup(    int choice, String girlname){
        this.choice=choice;
        this.girlname=getName();

    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //互相持有对方的锁，需要拿到对方的锁
    public void makeup()throws InterruptedException{
        if (choice==0){
            synchronized (lipatick){
                System.out.println(this.girlname+"获得口红的锁");
                    Thread.sleep(1000);//一秒钟之后想获得镜子的锁

            }
            synchronized (m){
                System.out.println(this.girlname+"获得镜子的锁");
            }

            }else {
            synchronized (m){
                System.out.println(this.girlname+"获得镜子的锁");
                Thread.sleep(2000);

            }
            synchronized (lipatick){
                System.out.println(this.girlname+"获得口红的锁");

            }

        }
    }
}

Lock锁

ReentrantLock：可重复锁

package cx.javathread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName JavaLock
 * Description TOOD
 * Author CX
 * Date 2021/4/27 10:02
 */
public class JavaLock implements Runnable{
    public static void main(String[] args) {
        JavaLock j1=new JavaLock();
        JavaLock j2=new JavaLock();

        Thread t1=new Thread(j1,"t1");
        Thread t2=new Thread(j1,"t2");
        t1.start();
        t2.start();
    }

    int tick=10;
    private final ReentrantLock lock=new ReentrantLock();//定义Lock锁
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if(tick>0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(tick--);
                }else {
                    break;
                }

            }finally {
                lock.unlock();//释放锁
            }


            }

        }

    }

synchronized和Lock的对比

线程协作：

线程协作

管程法

/**
 * @ClassName TestPC
 * Description 测试生产者消费者模型，利用缓冲区解决：管程法
 * Author CX
 * Date 2021/4/27 10:21
 */
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer() ;
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container=container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了--》"+container.pop().id+"只鸡");
        }

    }
}
//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}
class SynContainer{

    Chicken[] chickens=new Chicken[10];//容器
    int count=0;//计数器
    //放入产品
    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count]=chicken;
        count++;

        //通知消费者消费了
        this.notify();
    }
    public  synchronized  Chicken pop(){
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken=chickens[count];
        //通知生产者生产了
        this.notify();
        return chicken;


    }
}

信号灯法：

/**
 * @ClassName TestPC2
 * Description 信号灯法
 * Author CX
 * Date 2021/4/27 10:58
 */
public class TestPC2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new  Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv=tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("快乐大本营");
            }else {
                this.tv.play("抖音");
            }
        }

    }
}

//消费者--观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}

//产品--节目

class TV{
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice;//表演的节目
    boolean flag=true; //标志位


    //表演
    public  synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();//演员等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);
        this.notifyAll();//通知唤醒
        this.voice=voice;
        this.flag=!this.flag;
    }

    public synchronized void watch(){
        if (flag) {
            try {
                this.wait();//观众等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了"+voice);
        this.notifyAll();//唤醒表演者
        this.flag=!this.flag;

    }
}

线程池

线程池使用

线程池的使用

package cx.javathread;

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

/**
 * @ClassName TestPool
 * Description 测试线程池实现Runnable接口
 * Author CX
 * Date 2021/4/27 11:13
 */
public class TestPool {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(10);//创建线程池，newFixedThreadPool（参数）参数为线程池的大小
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭连接
        service.shutdownNow();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {

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

    }
}