把synchronized当作函数修饰符时,示例代码如下:

  

  1. Public synchronized void method(){
  2. //….
  3. }

  这也就是同步方法,那这时synchronized锁定的是哪个对象呢?他锁定的是调用这个同步方法对象。也就是说,当一个对象P1在不同的线程中执行这个同步方法时,他们之间会形成互斥,达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了synchronized关键字的方法。

  如同这样

  1. public void method()
  2. {
  3. synchronized (this) // (1)
  4. {
  5. //…..
  6. }
  7. }

  此处的this指的是什么呢?他指的就是调用这个方法的对象,如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程,才能够调用P1的同步方法,而对P2而言,P1这个锁和他毫不相干,程式也可能在这种情形下摆脱同步机制的控制,造成数据混乱。具体使用像这样:

  

  1. package com.java.Thread;
  2.  
  3. public class Mysynchronized {
  4. /**
  5. * @param args
  6. */
  7. public static void main(String[] args) {
  8. /*
  9. * GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
  10. * GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
  11. * gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
  12. * gt3.start();
  13. */
  14. GetTickets2 gt = new GetTickets2();
  15. Thread th1 = new Thread(gt, "窗口一");
  16. Thread th2 = new Thread(gt, "窗口二");
  17. Thread th3 = new Thread(gt, "窗口三");
  18. th1.start();
  19. try {
  20. Thread.sleep(500);
  21. } catch (InterruptedException e) {
  22. // TODO Auto-generated catch block
  23. e.printStackTrace();
  24. }
  25. gt.flag = true;
  26. th2.start();
  27. th3.start();
  28. }
  29.  
  30. }
  31.  
  32. class GetTickets2 implements Runnable {
  33.  
  34. private int tickets = 10;
  35. boolean flag = false;
  36. /* Object ob = new Object();*/
  37. public void run() {
  38. if (flag) {
  39. for (int i = 0; i < 10; i++) {
  40. //synchronized (ob) {//如果用ob就无法同步
  41. synchronized (this) {
  42. if (tickets > 0) {
  43. try {
  44. Thread.sleep(500);
  45. } catch (InterruptedException e) {
  46. e.printStackTrace();
  47. }
  48. System.out.println(Thread.currentThread().getName()
  49. + "卖出" + (tickets--) + "号票"+":同步代码块");
  50. }
  51. }
  52.  
  53. }
  54.  
  55. } else {
  56. for (int i = 0; i < 10; i++) {
  57. function();
  58.  
  59. }
  60.  
  61. }
  62. }
  63.  
  64. public synchronized void function() {
  65.  
  66. if (tickets > 0) {
  67. try {
  68. Thread.sleep(500);
  69. } catch (InterruptedException e) {
  70. e.printStackTrace();
  71. }
  72. System.out.println(Thread.currentThread().getName() + "卖出"
  73. + (tickets--) + "号票"+":同步函数");
  74.  
  75. }
  76. }
  77.  
  78. }
  79. /*
  80. * class GetTickets extends Thread{ //private static int tickets = 10; private
  81. * int tickets = 10; public void run(){
  82. *
  83. * for (int i = 0; i < 10; i++) { if(tickets>0){
  84. * System.out.println(Thread.currentThread().getName()+"卖出"+(tickets--)+"号票"); }
  85. * } } }
  86. */

  将synchronized作用于static 函数 同步的锁就是它自己本身的字节码,示例代码如下:

  1. Class Foo
  2. {
  3. public synchronized static void method1() // 同步的static 函数
  4. {
  5. //….
  6. }
  7. public void method2()
  8. {
  9. synchronized(Foo.class) // class literal(类名称字面常量)
  10. }
  11. }

具体代码如下

  1. package cn.java.thread;

    /*
    证明同步函数用的是this这把锁
    */
    public class Tickets1 {

    /**
    * @param args
    */
    public static void main(String[] args) {
    /*
    * GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
    * GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
    * gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
    * gt3.start();
    */
    GetTickets2 gt = new GetTickets2();
    Thread th1 = new Thread(gt, "窗口一");
    Thread th2 = new Thread(gt, "窗口二");
    Thread th3 = new Thread(gt, "窗口三");
    th1.start();
    try {
    Thread.sleep(500);
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    gt.flag = true;
    th2.start();
    th3.start();
    }

    }

    class GetTickets2 implements Runnable {

    private static int tickets = 10;
    boolean flag = false;
    Object ob = new Object();
    public void run() {
    if (flag) {
    for (int i = 0; i < 10; i++) {
    //synchronized (this.getClass()) {
    synchronized (GetTickets2.class) {
    if (tickets > 0) {
    try {
    Thread.sleep(500);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()
    + "卖出" + (tickets--) + "号票"+":同步代码块");
    }
    }

    }

    } else {
    for (int i = 0; i < 10; i++) {
    function();

    }

    }
    }

    public static synchronized void function() {

    if (tickets > 0) {
    try {
    Thread.sleep(500);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + "卖出"
    + (tickets--) + "号票"+":同步函数");

    }
    }

    }
    /*
    * class GetTickets extends Thread{ //private static int tickets = 10; private
    * int tickets = 10; public void run(){
    *
    * for (int i = 0; i < 10; i++) { if(tickets>0){
    * System.out.println(Thread.currentThread().getName()+"卖出"+(tickets--)+"号票"); }
    * } } }
    */

然后嘞是 wait notify notifyall 这三个(两个)方法的 理解了 第一步 wait的作用是阻塞 notify的作用是唤醒

  讲这个 要用到以前学到的生产者和消费者 对于他们的理解:

  1.这些方法都存在与同步中

  2;使用这些方法时必须要标记所属的同步锁

  3:锁可以是任意对象,所以任意对象调用的方法一定定义在object类中  废话不多上代码:

  这是同步代码块的

  1. package com.java.Thread;
  2. //定义一个rbq
  3. class Production{
  4. private String name;
  5. private String country;
  6. private boolean flag = true;
  7. public boolean isFlag() {
  8. return flag;
  9. }
  10. public void setFlag(boolean flag) {
  11. this.flag = flag;
  12. }
  13. public String getCountry() {
  14. return country;
  15. }
  16. public void setCountry(String country) {
  17. this.country = country;
  18. }
  19.  
  20. public void setName(String name) {
  21. this.name = name;
  22. }
  23. public String getName() {
  24. return name;
  25. }
  26.  
  27. }
  28. class Producer implements Runnable{
  29. private Production p = null;
  30.  
  31. public Producer(Production p) {
  32. this.p = p;
  33. }
  34. public void run(){
  35. boolean b = true;
  36. while(true){
  37. synchronized (p) {
  38. if(p.isFlag()){
  39. //这个b就是打酱油的
  40. if(b){
  41. p.setName("李小文院士");
  42. p.setCountry("中国");
  43. b = false;
  44. }
  45. else{
  46. p.setName("加来道雄博士");
  47. p.setCountry("日本");
  48. b = true;
  49. }
  50. //唤醒 并且这里注意 把flag改变成了 false
  51. p.setFlag(false);
  52. p.notify();
  53. }
  54. else
  55. try {
  56. //老样子 否则就过来阻塞
  57. p.wait();
  58. } catch (Exception e) {
  59. // TODO: handle exception
  60. }
  61.  
  62. }
  63.  
  64. }
  65. }
  66.  
  67. }
  68. class Saler implements Runnable{
  69. private Production p = null;
  70. //表明同步的锁!!!!
  71. public Saler(Production p) {
  72. this.p = p;
  73. }
  74.  
  75. public void run() {
  76. while(true){
  77. synchronized (p) {
  78. //上面的 isFlage被设定成 false了 所以这里要不等于 然后他们 就这样一直轮回下去 下面没了就让上面造
  79. if(!p.isFlag()){
  80. //获取前面的 赋值
  81. System.out.println(p.getName()+":"+p.getCountry());
  82. p.setFlag(true);
  83. //唤醒 动起来
  84. p.notify();
  85. }
  86. else{
  87. try {
  88. //阻塞
  89. p.wait();
  90. } catch (Exception e) {
  91. // TODO: handle exception
  92. }
  93.  
  94. }
  95.  
  96. }
  97.  
  98. }
  99.  
  100. }
  101.  
  102. }
  103.  
  104. public class ProductionDemo{
  105. public static void main(String[] args) {
  106. Production p = new Production();
  107. Producer producer = new Producer(p);
  108. Saler saler = new Saler(p);
  109. Thread th1 = new Thread(producer);
  110. Thread th2 = new Thread(saler);
  111. th1.start();
  112. th2.start();
  113.  
  114. }
  115. }

小钢炮这个是同步函数的

  1. public class ProductionDemo{
  2. public static void main(String[] args) {
  3. // 这是同步函数的
  4. /* Production p = new Production();
  5. Producer producer = new Producer(p);
  6. Saler saler = new Saler(p);
  7. Thread th1 = new Thread(producer);
  8. Thread th2 = new Thread(saler);
  9. th1.start();
  10. th2.start();
  11. */
  12. //同步代码块
  13. Production p = new Production();
  14. Producer pd = new Producer(p);
  15. Saler s = new Saler(p);
  16. Thread th1 = new Thread(pd);
  17. Thread th2 = new Thread(s);
  18. th1.start();
  19. th2.start();
  20.  
  21. }
  22. }
  23.  
  24. //同步代码块
  25. class Production {
  26. private String name;
  27. private int num = 0;
  28. private boolean b = false;
  29.  
  30. public boolean isB() {
  31. return b;
  32. }
  33.  
  34. public void setB(boolean b) {
  35. this.b = b;
  36. }
  37.  
  38. public String getName() {
  39. return name;
  40. }
  41.  
  42. public void setName(String name) {
  43. this.name = name;
  44. }
  45.  
  46. public int getNum() {
  47. return num;
  48. }
  49.  
  50. public void setNum(int num) {
  51. this.num = num;
  52. }
  53.  
  54. }
  55.  
  56. class Producer implements Runnable {
  57.  
  58. private Production p = null;
  59.  
  60. public Producer(Production p) {
  61. this.p = p;
  62. }
  63.  
  64. public void run() {
  65. while (true) {
  66. synchronized (p) {
  67. if (p.isB()) {
  68. try {
  69. p.wait();
  70. } catch (InterruptedException e) {
  71. // TODO Auto-generated catch block
  72. e.printStackTrace();
  73. }
  74. }
  75. p.setName("小钢炮");
  76. p.setNum(p.getNum() + 1);
  77. System.out.println("生产:" + p.getName() + p.getNum());
  78. p.setB(true);
  79. p.notify();
  80.  
  81. }
  82.  
  83. }
  84.  
  85. }
  86.  
  87. }
  88.  
  89. class Saler implements Runnable {
  90.  
  91. private Production p = null;
  92. //获取定义的锁要一样
  93. public Saler(Production p) {
  94. this.p = p;
  95. }
  96.  
  97. public void run() {
  98. while (true) {
  99. synchronized (p) {
  100. if (!p.isB()) {
  101. try {
  102. //阻塞
  103. p.wait();
  104. } catch (InterruptedException e) {
  105. // TODO Auto-generated catch block
  106. e.printStackTrace();
  107. }
  108. }
  109. System.out.println("卖:" + p.getName() + p.getNum());
  110. p.setB(false);
  111. //唤醒
  112. p.notify();
  113. }
  114. }
  115. }
  116.  
  117. }

然后了是多生产者和多消费者 嘿嘿上码:

  1. package cn.java.thread1;
  2.  
  3. public class ProductionDemo2 {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. Production2 p = new Production2();
  10. Producer2 pd = new Producer2(p);
  11. Saler2 s = new Saler2(p);
  12. Thread th1 = new Thread(pd);
  13. Thread th2 = new Thread(pd);
  14. Thread th3 = new Thread(s);
  15. Thread th4 = new Thread(s);
  16. Thread th5 = new Thread(pd);
  17. Thread th6 = new Thread(s);
  18. th1.start();
  19. th2.start();
  20. th3.start();
  21. th4.start();
  22. th5.start();
  23. th6.start();
  24.  
  25. }
  26.  
  27. }
  28.  
  29. class Production2 {
  30. private String name;
  31. private int num = 0;
  32. private boolean b = false;
  33.  
  34. public boolean isB() {
  35. return b;
  36. }
  37.  
  38. public void setB(boolean b) {
  39. this.b = b;
  40. }
  41.  
  42. public String getName() {
  43. return name;
  44. }
  45.  
  46. public void setName(String name) {
  47. this.name = name;
  48. }
  49.  
  50. public int getNum() {
  51. return num;
  52. }
  53.  
  54. public void setNum(int num) {
  55. this.num = num;
  56. }
  57.  
  58. public synchronized void produce() {
  59. //if (b) {
  60. while (b) {
  61. try {
  62. this.wait();
  63. } catch (InterruptedException e) {
  64. // TODO Auto-generated catch block
  65. e.printStackTrace();
  66. }
  67. }
  68. setName("小钢炮");
  69. setNum(getNum() + 1);
  70. System.out.println("生产:" + getName() + getNum());
  71. setB(true);
  72. //notify();
  73. notifyAll();
  74. }
  75.  
  76. public synchronized void sale() {
  77. //if (!b) {
  78. while(!b){
  79. try {
  80. this.wait();
  81. } catch (InterruptedException e) {
  82. // TODO Auto-generated catch block
  83. e.printStackTrace();
  84. }
  85.  
  86. }
  87. System.out.println("卖:" + getName() + getNum());
  88. setB(false);
  89. //notify();
  90. notifyAll();
  91.  
  92. }
  93. }
  94.  
  95. class Producer2 implements Runnable {
  96.  
  97. private Production2 p = null;
  98.  
  99. public Producer2(Production2 p2) {
  100. this.p = p2;
  101. }
  102.  
  103. public void run() {
  104. for (int i = 0; i < 100; i++) {
  105. p.produce();
  106.  
  107. }
  108.  
  109. }
  110.  
  111. }
  112.  
  113. class Saler2 implements Runnable {
  114.  
  115. private Production2 p = null;
  116.  
  117. public Saler2(Production2 p2) {
  118. this.p = p2;
  119. }
  120.  
  121. public void run() {
  122. for (int i = 0; i < 100; i++) {
  123. p.sale();
  124. }
  125.  
  126. }
  127.  
  128. }

Java线程同步锁的更多相关文章

  1. java 线程同步 原理 sleep和wait区别

    java线程同步的原理java会为每个Object对象分配一个monitor, 当某个对象(实例)的同步方法(synchronized methods)被多个线程调用时,该对象的monitor将负责处 ...

  2. 【总结】Java线程同步机制深刻阐述

    原文:http://hxraid.iteye.com/blog/667437 我们可以在计算机上运行各种计算机软件程序.每一个运行的程序可能包括多个独立运行的线程(Thread). 线程(Thread ...

  3. Java线程同步_1

    Java线程同步_1 synchronized 该同步机制的的核心是同步监视器,任何对象都可以作为同步监视器,代码执行结束,或者程序调用了同步监视器的wait方法会导致释放同步监视器 synchron ...

  4. Java线程同步之一--AQS

    Java线程同步之一--AQS 线程同步是指两个并发执行的线程在同一时间不同时执行某一部分的程序.同步问题在生活中也很常见,就比如在麦当劳点餐,假设只有一个服务员能够提供点餐服务.每个服务员在同一时刻 ...

  5. Java线程:锁

    一.锁的原理 Java中每个对象都有一个内置锁,当程序运行到非静态的synchronized同步方法上时,自动获得与正在执行的代码类的当前实例(this实例)有关的锁.获得一个对象的锁也称为获取锁.锁 ...

  6. JAVA - 线程同步和线程调度的相关方法

    JAVA - 线程同步和线程调度的相关方法 wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁:wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等 ...

  7. Java线程同步的四种方式详解(建议收藏)

    ​ Java线程同步属于Java多线程与并发编程的核心点,需要重点掌握,下面我就来详解Java线程同步的4种主要的实现方式@mikechen 目录 什么是线程同步 线程同步的几种方式 1.使用sync ...

  8. java线程 同步临界区:thinking in java4 21.3.5

    java线程 同步临界区:thinking in java4 21.3.5 thinking in java 4免费下载:http://download.csdn.net/detail/liangru ...

  9. Python之路(第四十四篇)线程同步锁、死锁、递归锁、信号量

    在使用多线程的应用下,如何保证线程安全,以及线程之间的同步,或者访问共享变量等问题是十分棘手的问题,也是使用多线程下面临的问题,如果处理不好,会带来较严重的后果,使用python多线程中提供Lock ...

随机推荐

  1. java并发包分析之———BlockingQueue

    一.概述: BlockingQueue作为线程容器,可以为线程同步提供有力的保障.   二.BlockingQueue定义的常用方法 1.BlockingQueue定义的常用方法如下:   抛出异常 ...

  2. 全局程序集缓存GAC

    GAC中的所有的Assembly都会存放在系统目录"%winroot%\assembly下面.放在系统目录下的好处之一是可以让系统管理员通过用户权限来控制Assembly的访问. 目录:C: ...

  3. 在Django中使用Neo4j

    重要的先说在前面吧,最后的选型结构是安装了最新的neo4j版本3.0.3,使用了neo4j-rest-client客户端库.主要原因是更适用于django的neomodel库目前只支持neo4j2.2 ...

  4. Fiddler抓包使用教程-断点调试

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/62896784 本文出自[赵彦军的博客] Fiddler 里面的断点调试有2种方式. ...

  5. Vue--学习过程中遇到的坑

    在这里总结一下学习Vue遇到的易错点,持续更新 1.实例化一个Vue对象: 通过new Vue({ el:'#id', data:{ a:'字符串1', b:‘字符串2’ }) 这里的Vue必须大写V ...

  6. 第一章 C++概述

    第一节 C++语言的发展历史 略 第二节 C++语言的特点 1.C++是一种面向对象的程序设计语言,其中的新技术主要包括: 抽象数据类型 封装和信息隐蔽 以继承和派生方式实现程序的重用 以运算符重载和 ...

  7. windows下安装mysql-5.7.11-winx64

    1.解压.   2.将『D:\Program Files\mysql-5.7.11-winx64\bin』加入系统环境变量.   3.修改my-default.ini.   4.初始化data目录,在 ...

  8. git-------基础(一)

    更改连接仓库只用操作一次(先删后加) (1)git remote rm origin                                  //若本地已经关联了一个远程库,则先删除已关联的 ...

  9. 升讯威微信营销系统开发实践:(4)源代码结构说明 与 安装部署说明( 完整开源于 Github)

    GitHub:https://github.com/iccb1013/Sheng.WeixinConstruction因为个人精力时间有限,不会再对现有代码进行更新维护,不过微信接口比较稳定,经测试至 ...

  10. Map集合学习总结

    1.Map接口定义的集合又称查找表,用于存储所谓的 key-value  映射对,key可以看成是value的索引,作为key的对象在集合中不可以重复 根据内部数据结构的不同Map接口有多重实现类,其 ...