文档章节

传统线程互斥与同步通信

王大叔爱编程
 王大叔爱编程
发布于 2014/05/26 17:30
字数 432
阅读 29
收藏 0

    对于传统线程互斥,最重要的一点就是必须要拿到同一个对象锁。

    特别说明的是,如果想静态方法互斥,则需要同步字节码对象锁。

package com.wangbiao.thread;

/**
 * @author wangbiao
 * @date and time May 26, 2014 5:03:56 PM 传统线程互斥
 */
public class TraditionalThreadSynchronized {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final Output output = new Output();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    output.output("zhangsan");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // output.output("lisi");
                    new Output().output3("lisi");
                }
            }
        }).start();

    }

    static class Output {
        // String xxx = "";
        public void output(String name) {
            int len = name.length();
            /*
             * synchronized (xxx) { for (int i = 0; i < len; i++) {
             * System.out.print(name.charAt(i)); } System.out.println(); }
             */
            /*
             * synchronized (this) { for (int i = 0; i < len; i++) {
             * System.out.print(name.charAt(i)); } System.out.println();
             */

            synchronized (Output.class) {
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }

        public synchronized void output2(String name) {
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

        public synchronized static void output3(String name) {// 不同步,因为static是字节码对象所有,与调用output2的对象不是同一个对象,除非都是拿的字节码对象锁
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

package com.wangbiao.thread;

/**
 * @author wangbiao
 * @date and time May 27, 2014 10:54:25 AM 线程同步通信
 * 调用sub()10次,然后再调用main()100次,循环50次,如此重复
 */
public class TraditionalThreadCommunication {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final Process pro = new Process();
        
        // sub thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    System.out.println("invoke the method sub()"+"-"+i);
                    pro.sub();
                }
            }
        }).start();
        
        // main thread
        for (int i = 0; i < 50; i++) {
            System.out.println("invoke the method main()"+"-"+i);
            pro.main();
        }
    }
}

class Process {
    
    boolean subThread = true;

    public synchronized void sub() {
        
        while(!subThread){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        for (int i = 0; i < 10; i++) {
            System.out.println("sub thread "+ i);
        }
        
        subThread = false;
        this.notify();
    }

    public synchronized void main() {

        while(subThread){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        for (int i = 0; i < 10; i++) {
            System.out.println("main thread "+ i);
        }
        subThread = true;
        this.notify();
    }
}


© 著作权归作者所有

王大叔爱编程

王大叔爱编程

粉丝 34
博文 111
码字总数 61053
作品 0
成都
程序员
私信 提问
传统线程同步通信技术

子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,接着再回到主线程又循环100次,如此循环50次,请写出程序。 一、代码实现 二、注意 1、Lock比传统线程模型中的synchronize...

哎小艾
2018/01/16
8
0
Synchronized与Lock

Synchronized是并发中使用最频繁的关键字了,它可以使用在方法、代码块上,表示对该段代码加锁,而必须要持有锁才能执行这段代码。Synchronized具有互斥性。 说起来蛮简单,而实际中编程 ,最...

EveryDayNew
2016/10/02
73
0
20.进程与线程通信方式之间的差异

进程线程通信方式之间的差异 每个进程有自己的地址空间。两个进程中的地址即使值相同,实际指向的位置也不同。进程间通信一般通过操作系统的公共区进行。 同一进程中的线程因属同一地址空间,...

u014590757
2018/04/16
0
0
Java基础巩固笔记(6)-多线程之传统多线程

Contents java基础巩固笔记(5)-多线程之传统多线程 传统线程技术 传统创建线程方式 传统定时器技术 互斥 同步 传统线程技术 传统创建线程方式 1.继承Thread类,覆盖run方法 2.实现Runnable接...

卟想苌亣
2017/12/04
0
0
同步访问共享的可变数据(66)

关键字synchronized 保证同一时刻,只有一个线程执行某一个方法或代码块 当一个对象被一个线程修改时,可以阻止其他线程看到其内部的不一致状态 正确的使用同步可以避免任何对象看到其不一致...

Java搬砖工程师
2018/12/12
6
0

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周日乱弹 —— 我,小小编辑,食人族酋长

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @宇辰OSC :分享娃娃的单曲《飘洋过海来看你》: #今日歌曲推荐# 《飘洋过海来看你》- 娃娃 手机党少年们想听歌,请使劲儿戳(这里) @宇辰OSC...

小小编辑
今天
527
10
MongoDB系列-- SpringBoot 中对 MongoDB 的 基本操作

SpringBoot 中对 MongoDB 的 基本操作 Database 库的创建 首先 在MongoDB 操作客户端 Robo 3T 中 创建数据库: 增加用户User: 创建 Collections 集合(类似mysql 中的 表): 后面我们大部分都...

TcWong
今天
29
0
spring cloud

一、从面试题入手 1.1、什么事微服务 1.2、微服务之间如何独立通讯的 1.3、springCloud和Dubbo有哪些区别 1.通信机制:DUbbo基于RPC远程过程调用;微服务cloud基于http restFUL API 1.4、spr...

榴莲黑芝麻糊
今天
16
0
Executor线程池原理与源码解读

线程池为线程生命周期的开销和资源不足问题提供了解决方 案。通过对多个任务重用线程,线程创建的开销被分摊到了多个任务上。 线程实现方式 Thread、Runnable、Callable //实现Runnable接口的...

小强的进阶之路
昨天
42
0
maven 环境隔离

解决问题 即 在 resource 文件夹下面 ,新增对应的资源配置文件夹,对应 开发,测试,生产的不同的配置内容 <resources> <resource> <directory>src/main/resources.${deplo......

之渊
昨天
54
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部