首页 > > 程序设计 > Java技术 >

java学习进阶之 一 （线程基础）

2019-11-03 16:05:44来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

java学习进阶之 一 （线程基础）

一、线程安全

线程安全的概念:当多个线程访问某一个类（对象或方法）时。这个类始终都能表现出正确的行为那么这个类（对象或方法）就是线程安全的。

synchronized:可以在任何对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

示例：【com.study.base.thread.a_sync.sync001】MyThread

package com.study.base.thread.a_sync.sync001;
/**
 * 
 *        线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）
 *    就是线程安全的
 *        synchronized:可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
 *    
 *    示例总结
 *        当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），
 *    一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；
 *    拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。
 */
public class MyThread implements Runnable {
    private int count = 5;
    
    //synchronized 加锁
    public synchronized void run() {
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count);
    }
    
    public static void main(String[] args) {
        /**
         *     分析：
         *         当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排队是按照cpu分配的先后顺序而定的）
         *         1  尝试获得锁
         *         2 如果拿到锁，执行synchronized代码体内容：拿不到锁出，这个线程就会不断的尝试获得这把锁，直到拿到为止
         *         而且是多个线程同时去竞争这把锁，也就是会有锁竞争的问题
         */
        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");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
         
    }
}
MyThread

示例总结

    当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。

二、多个线程多个锁

多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容

示例：【com.study.base.thread.a_sync.sync002】MultiThread

package com.study.base.thread.a_sync.sync002;
/**
 *     多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容
 *        关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响
 *    有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.
 */
public class MultiThread {
    private int num = 0;
    public 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");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("tag "+tag+" , num = "+num);
    }
    //注意观察run方法的输出顺序
    public static void main(String[] args) {
        //两个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();
        
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m1.printNum("a");
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m2.printNum("b");
            }
        },"t2");
        t1.start();
        t2.start();
    }
}
MultiThread

示例总结

    关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响 有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.

三、对象锁的同步和异步

同步：synchronized 同步的概念就是共享，我们要牢牢记住“共享”这两个字，如果不是共享的资源，就没有必要进行同步

异步：asynchronized 异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，在页面发起的Ajax请求,我们还可以继续浏览操作页面的内容，两者之间没有任何关系

同步的目的就是为了线程安全，其实对于线程安全来说，需要满足两个特性：

　　原子性（同步）

　　可见性

示例：【com.study.base.thread.a_sync.sync003】MyObject

 

package com.study.base.thread.a_sync.sync003;
/**
 * 
 * 对象的同步和异步问题
 *
 */
public class MyObject {
    public synchronized void method1() {
        try {
            System.out.print(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /** synchronized */
    public void method2() {
        System.out.println(Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        final MyObject mo = new MyObject();
        /**
         * 分析：
         * t1线程先持有object对象的lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
         * t1线程先持有object对象的lock锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步
         */
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method2();
            }
        },"t2");
        t1.start();
        t2.start();
    }
}
MyObject

 

示例总结

    A线程先持有object对象的Lock锁，B线程如果在这个时候调用对象的同步（synchronized）方法则需要等待，也就是同步 ?

    A线程先持有object对象的Lock锁，B线程可以以异步的方式调用对象中的非synchronized修饰的方法

四、脏读

    对于对象的同步和异步方法，我们在设计自己的程序的时候，一定要考虑问题的整体，不然会出现数据不一致的错误，很经典的错误就是脏读（dirtyread）

示例：【com.study.base.thread.a_sync.sync004】DirtyRead

package com.study.base.thread.a_sync.sync004;

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性
 * 
 *
 */
public class DirtyRead {
    private String username = "Rang";
    private String password = "123";
    public synchronized void setValue(String username, String password) {
        this.username = username;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        this.password = password;
        
        System.out.println("setValue最终结果, username = " + username + " password = " + password);
    } 
    
    public synchronized void getValue() {
        System.out.println("getValue方法得到, username = " + username + " password = " + password);
    }
    
    public static void main(String[] args) throws InterruptedException {
        
        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                dr.setValue("z3", "456");
            }
            
        },"t1");
        t1.start();
        Thread.sleep(1000);
        
        dr.getValue();
        
    }
            
}
DirtyRead

示例总结：

    在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue / getValue 方法同时加锁synchronized同步的关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）。

 


原文链接:https://www.cnblogs.com/liu520/p/11789910.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：b站最好的Java教程

下一篇：【Java必修课】通过Value获取Map中的键值Key的四种方法

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签