首页 > 其他分享> 文章详细

2022-08-03 第四小组王星苹学习笔记

2022-08-03 20:32:10 阅读：99 来源： 互联网

标签：03 Thread synchronized 08 线程 void 2022 new public

###学习心得###

###心情###

今日掌握情况还可以，比昨天理解的透彻一点，线程方面对于加锁死锁有时候不知道什么时候放会更好，但是已经知道了锁的基本作用

锁：

1.synchronized多线程并发编程。

重量级锁。JDK1.6对synchronized进行了优化。

JDK1.6为了减少获得锁和释放锁带来的性能消耗引入的偏向锁和轻量级锁。

synchronized有三种方式来加锁，分别是：

1.修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
2.静态方法，作用于当前类对象加锁，进入同步代码前要获得的当前类对象的锁
3.代码块，指定加锁对象，对给定对象加锁，进入同步代码块之前要获得给定对象的锁

1.实例方法：调用该方法的实例

2.静态方法：类对象

3.this：调用该方法的实例对象

4.类对象：类对象

操作共享数据的代码

共享数据：多个线程共同操作的变量，都可以充当锁

当使用同步方法时，synchronized锁的东西是this（默认的）

关于同步方法：

1.同步方法依然涉及到同步锁对象，不需要我们写出来

2.非静态的同步方法，同步锁就是this

静态的同步方法，同步监视器就是类本身

同步代码块：

1.选好同步监视器（锁）推荐使用类对象，第三方对象，this

2.在实现接口创建的线程类中，同步代码块不可以用this来充当同步锁

同步的方式，解决线程安全的问题。

操作同步代码时，只有一个线程能够参与，其他线程等待。相当于一个单线程的过程，效率低。

synchronized只针对于当前JVM可以解决线程安全问题。

synchronized不可以跨JVM解决问题！！！

加锁了的买票：---练习---

class Window3 extends Thread {
    private static int ticket = 100;

    private String name;

    public Window3(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        sell();
    }


    private synchronized void sell() {
        while(true) {
            if(ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
            }else {
                break;
            }
        }
    }
}
public class Ch03 {

    public static void main(String[] args) {
        Window3 w1 = new Window3("窗口一");
        Window3 w2 = new Window3("窗口二");

        w1.start();
        w2.start();

死锁：

死锁是这样一种情形：多个线程同时被阻塞，他们中的一个或者全部都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止。

java死锁产生四个必要条件

1.互斥使用，当资源被一个线程使用（占用），别的线程不能使用。

2.不可抢占，资源请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放

3.请求和保持

4.循环等待，存在一个等待队列。P1占有P2的资源，P2占有了P3的资源。P3占有P1的资源。形成了一个等待环路。

死锁：---练习---

class LockA implements Runnable {


    @Override
    public void run() {
        System.out.println(new Date().toString() + "LockA开始执行...");
        try {
            while (true) {
                synchronized (Ch04.obj1) {
                    System.out.println(new Date().toString() + "LockA锁住了obj1");


                    Thread.sleep(8000);
                }
                synchronized (Ch04.obj2) {
                    System.out.println(new Date().toString() + "LockA锁住了obj2");
                    Thread.sleep(70*1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class LockB implements Runnable {


    @Override
    public void run() {
        System.out.println(new Date().toString() + "LockB开始执行...");
        try {
            while (true) {
                synchronized (Ch04.obj2) {
                    System.out.println(new Date().toString() + "LockB锁住了obj2");
                    Thread.sleep(6000); //3s
                }
                synchronized (Ch04.obj1) {
                    System.out.println(new Date().toString() + "LockB锁住了obj1");
                    Thread.sleep(100*1000); // 1min
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Ch04 {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";


    public static void main(String[] args) {
        LockA lockA = new LockA();
        new Thread(lockA).start();
        LockB lockB = new LockB();
        new Thread(lockB).start();

线程重入：

任意线程在拿到锁之后，再次获取该锁不会被该锁所阻碍

线程不会被自己锁死的。

这就叫线程的重入，synchronized可重入锁。

JDK1.6以后锁升级：

1.无锁：不加锁

2.偏向锁：不锁锁，只有一个线程争夺时，偏向某一个线程，这个线程不加锁

3.轻量级锁：少量线程来了之后，向尝试自旋，不挂起线程。

4.重量级锁：排队挂起（暂停）线程。（synchronized）

挂起线程和恢复线程需要转入内核态中完成这些操作，给系统的并发性带来很大的压力。

在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得。我们可以让后面的线程等待一下，不要放弃处理器的执行时间。锁为了让线程等待，我们只需要让线程。执行一个循环，自旋。【自旋锁】

hashcode值1 0

public class Ch05 {


    private static final Object M1 = new Object();
    private static final Object M2 = new Object();


    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (M1) {
                synchronized (M2) {
                    synchronized (M1) {
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();
    }

Object类对多线程的支持：

wait():

wait(long timeout):当前线程进入等待状态

notify()：唤醒正在等待的下一个线程

notifyAll()：唤醒正在等待的所有线程

线程间的通信：

比如两条线程，共同运行。线程A如果先走，线程B就要等待。等待线程A走完，唤醒线程B，线程B再走

public class Ch01 {

    private static int num = 10;

    private static final Object OBJ = new Object();

    public static void plus(int code,int i) {
        synchronized (OBJ) {
            if(num >= 10){
                // 唤醒其他等待的线程
//               OBJ.notify();
                // 唤醒所有等待的线程
                OBJ.notifyAll();
            }
            System.out.println("这是线程" + code + "->" + ++num + "->" + i);
        }
    }
    public static void sub(int code,int i) {
        synchronized (OBJ) {
            if(num <= 0){
                try {
                    // 减法上来就是等待的状态
                    OBJ.wait(200);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("这是线程" + code + "->" + --num + "->" + i);
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sub(1,i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0;; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                plus(2,i);
            }
        });
        t1.start();
        t2.start();


        System.out.println("--------------------------------------------------");

方法总结：

1.Thread的两个静态方法：

sleep 释放CPU资源，但是不会释放锁

yield 方法释放CPU执行权，保留了CPU的执行资格，不常用。

2.join方法，yield出让了执行权，join就加入进来。

3.wait：释放CPU资源，释放锁

notify：唤醒等待中的线程

notifyAll：唤醒等待中的所有线程

线程的退出

使用退出标志，线程正常退出，run方法结束后线程终止

不要使用stop方法。

System.exit(-1)

class MyThread extends Thread {


    volatile boolean flag = true;


    @Override
    public void run() {
        while(flag) {
            try {
                System.out.println("线程一直在运行...");
                int i = 10 / 0;
            } catch (Exception e) {
                this.stopThread();
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}


public class Ch03 {


    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

interrupt方法：

中断线程。

调用interrupt方法会抛出InterruptedException异常，捕获后再做停止线程的逻辑即可。如果线程while(true)运行的状态，interrupt方法无法中断线程。

class MyThread02 extends Thread {


    private boolean flag = true;


    @Override
    public void run() {
        while(flag) {
            synchronized (this){
//                try {
//                    wait();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                try {
                    sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    this.stopThread();
                }
            }
        }
    }
    public void stopThread() {
        System.out.println("线程停止运行...");
        this.flag = false;
    }
}
public class Ch04 {


//    public void show() {
//        try {
//            wait();
//            // 线程异常终止     异常
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//    }


    public static void main(String[] args) {
        MyThread02 myThread02 = new MyThread02();
        myThread02.start();


        System.out.println("线程开始...");


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程的执行
        myThread02.interrupt();



----------
----------

标签：03,Thread,synchronized,08,线程,void,2022,new,public
来源： https://www.cnblogs.com/wxp0909/p/16548280.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

2022-08-03 第四小组 王星苹 学习笔记