开发者社区> 山月风成> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

线程与锁的案例分析

简介: 线程安全 /* * 线程安全:当多个线程访问某一个类(方法、对象)时,这个类始终都能表现出正确的行为,那么其就是线程安全的。
+关注继续查看

线程安全

/*
 * 线程安全:当多个线程访问某一个类(方法、对象)时,这个类始终都能表现出正确的行为,那么其就是线程安全的。
 * synchronized:可以在任意对象及方法上加锁,而加锁的这段代码称为“互斥区”或“临界区”
 * 锁竞争
 */
package demo;

/**
 * 线程安全测试
 * @author 180285
 *  */
public class MyThread extends Thread{

    private int count = 5;

    //一个线程想要执行synchronized修饰的代码区,
    //1.尝试获得锁再执行;2.拿不到锁,就不断尝试获得直到得到为止。
    public synchronized void run(){
        count--;
        System.out.println(this.currentThread().getName()+"  count:"+count);
    }

    /**
     * 创建五个线程,线程不安全测试
     * @param args
     */
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");

        //线程执行的顺序,不是按代码书写的顺序,是按照CPU给线程分配的顺序。
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
结果:
没上锁:                        上锁
t2  count:2                     t1  count:4
t4  count:1                     t4  count:3
t5  count:0                     t5  count:2
t1  count:2                     t3  count:1
t3  count:2                     t2  count:0

多个线程多个对象、类级别的锁

package demo;

/*
 *  关键字synchronized取得的锁都是对象锁,而不是把一段代码(方法)锁起来;
 *  所以代码中哪个线程先执行synchronized关键字的方法,哪个线程就持有该方法所属对象的锁(Lock) new的新的对象就有新的锁;
 *  两个对象就有两个锁,互不影响
 *
 *  再静态方法上synchronized关键字,便是锁定class类,类层级的锁
 *
 */
public class MutiThread {

    private  static int num = 0;

    /*static 让这个方法的锁上升到类层面*/
    public static  synchronized void printNum(String tag){
        try {

            if (tag.equals("a")) {
                num = 100;
                System.out.println("tag a ,set num over");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("tag b, set num over");
            }

            System.out.println("tag"+tag+", num: "+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //test
    public static void main(String[] args) {

        final MutiThread m1 = new MutiThread();
        final MutiThread m2 = new MutiThread();

        //线程1
        Thread  t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        //线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                m2.printNum("b");
            }
        });

        //线程t1,t2开始
        t1.start(); 
        t2.start();
        //未加static——预期的结果是tag a, set num over, tag a ,num : 100;然后在执行t2,事实不是这样的
    }
}
结果:
static synchronized时的结果。

tag a ,set num over
taga, num: 100
tag b, set num over
tagb, num: 200

只有synchronized时的结果。

tag a ,set num over
tag b, set num over
tagb, num: 200
taga, num: 100

同步锁、异步锁

  • 方法,对象默认都是异步的asynchronized
package demo;

public class MyObject {

    public synchronized void method1(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /*默认是异步的,加锁会同步*/
    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName());
    }

    //test
    public static void main(String[] args) {

        final MyObject my1 = new MyObject();

        //线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                my1.method1();
            }
        },"t1");

        //线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                my1.method2();
            }
        },"t2");

        //开始t1,t2线程
        t1.start();
        t2.start();
        /*
         * 总结:
         * 多个线程、一个对象,t1,t2可以以异步的方式调用对象的非synchronized修饰的方法
         *              上锁的方法必须等待,一个对象只有一个锁。
         * */
    }
}
  • 上诉结果中,只是打印两个线程的名字,在method2方法没有锁时,t1,t2是同时打印的。上锁之后是先打印t1,4秒之后打印t2。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
线程
进程和线程 线程的生命周期 创建线程池的方法
146 0
线程
线程 注意:进程是资源分配的最小单位,线程是CPU调度的最小单位.     每一个进程中至少有一个线程。  线程与进程的区别可以归纳为以下4点:   1)地址空间和其它资源(如打开文件):进程间相互独立,同一进程的各线程间共享。
1195 0
详解线程的信号量和互斥锁
  前言:有个问题感觉一直会被问道:进程和线程的区别?也许之前我会回答: 进程:资源分配最小单位 线程:轻量级的进程 是系统调度的最小单位 由进程创建 多个线程共享进程的资源   但是现在我觉得一个比喻回答的更好:程序就像静止的火车,进程是运行的火车,线程是运行火车的每节车厢。
968 0
线程
程序:Program,是一个指令的集合。 进程:Process,(正在执行中的程序)是一个静态的概念。
619 0
线程锁实例2---读写加锁实例
#include #include #include struct student { int a ; int b ; int c ; int d ; int e ; int f ; }; char stu[6] = {10,10,10,10,10,10}; /...
789 0
+关注
山月风成
君子不以辞尽人,故天下有道,则行有枝叶;天下无道,则辞有枝叶。热爱技术岗位,因为这里单纯友好,自由和分享。
37
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载