实验十七  线程同步控制

实验时间 2018-12-10

学习总结:

1.Java通过多线程的并发运行提高系统资源利用 率,改善系统性能。

2.假设有两个或两个以上的线程共享 某个对象,每个线程都调用了改变该对象类状态的方法,就会引起的不确定性。

3.多线程并发执行中的问题

◆多个线程相对执行的顺序是不确定的。

◆线程执行顺序的不确定性会产生执行结果的不确定性。

◆在多线程对共享数据操作时常常会产生这种不确定性。

4.多线程并发运行不确定性问题解决方案:引入线程同步机制。

5.(1)锁对象与条件对象

用ReentrantLock保护代码块的基本结构如下:

myLock.lock();

try { critical section }

finally{

myLock.unlock();

}

(2)synchronized关键字

synchronized关键字作用:

➢ 某个类内方法用synchronized 修饰后,该方 法被称为同步方法;

➢ 只要某个线程正在访问同步方法,其他线程 欲要访问同步方法就被阻塞,直至线程从同 步方法返回前唤醒被阻塞线程,其他线程方 可能进入同步方法。

具体用法参考博客:https://blog.csdn.net/sinat_32588261/article/details/72880159

1、实验目的与要求

(1) 掌握线程同步的概念及实现技术;

(2) 线程综合编程练习

2、实验内容和步骤

实验1:测试程序并进行代码注释。

测试程序1:

l 在Elipse环境下调试教材651页程序14-7,结合程序运行结果理解程序;

l 掌握利用锁对象和条件对象实现的多线程同步技术。

代码:

  1. package synch;
  2.  
  3. import java.util.*;
  4. import java.util.concurrent.locks.*;
  5.  
  6. /**
  7. * A bank with a number of bank accounts that uses locks for serializing access.
  8. * @version 1.30 2004-08-01
  9. * @author Cay Horstmann
  10. */
  11. public class Bank
  12. {
  13. private final double[] accounts;//银行运转的基本数据
  14. private Lock bankLock;//锁对象
  15. private Condition sufficientFunds;//
  16.  
  17. /**
  18. * Constructs the bank.
  19. * @param n the number of accounts
  20. * @param initialBalance the initial balance for each account
  21. */
  22. public Bank(int n, double initialBalance)
  23. {
  24. accounts = new double[n];
  25. Arrays.fill(accounts, initialBalance);
  26. bankLock = new ReentrantLock();
  27. sufficientFunds = bankLock.newCondition();
  28. }
  29.  
  30. /**
  31. * Transfers money from one account to another.
  32. * @param from the account to transfer from
  33. * @param to the account to transfer to
  34. * @param amount the amount to transfer
  35. */
  36. public void transfer(int from, int to, double amount) throws InterruptedException
  37. {
  38. bankLock.lock();
  39. try
  40. {//锁对象的引用条件对象
  41. while (accounts[from] < amount)
  42. sufficientFunds.await();
  43. System.out.print(Thread.currentThread());//打印出线程号
  44. accounts[from] -= amount;
  45. System.out.printf(" %10.2f from %d to %d", amount, from, to);
  46. accounts[to] += amount;
  47. System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
  48. sufficientFunds.signal();
  49. }
  50. finally
  51. {
  52. bankLock.unlock();
  53. }
  54. }
  55.  
  56. /**
  57. * Gets the sum of all account balances.
  58. * @return the total balance
  59. */
  60. public double getTotalBalance()
  61. {
  62. bankLock.lock();//加锁
  63. try
  64. {
  65. double sum = 0;
  66.  
  67. for (double a : accounts)
  68. sum += a;
  69.  
  70. return sum;
  71. }
  72. finally
  73. {
  74. bankLock.unlock();//解锁
  75. }
  76. }
  77.  
  78. /**
  79. * Gets the number of accounts in the bank.
  80. * @return the number of accounts
  81. */
  82. public int size()
  83. {
  84. return accounts.length;
  85. }
  86. }
  1. package synch;
  2.  
  3. /**
  4. * This program shows how multiple threads can safely access a data structure.
  5. * @version 1.31 2015-06-21
  6. * @author Cay Horstmann
  7. */
  8. public class SynchBankTest
  9. {
  10. public static final int NACCOUNTS = 100;
  11. public static final double INITIAL_BALANCE = 1000;
  12. public static final double MAX_AMOUNT = 1000;
  13. public static final int DELAY = 10;
  14.  
  15. public static void main(String[] args)
  16. {
  17. Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
  18. for (int i = 0; i < NACCOUNTS; i++)
  19. {
  20. int fromAccount = i;
  21. Runnable r = () -> {
  22. try
  23. {
  24. while (true)
  25. {
  26. int toAccount = (int) (bank.size() * Math.random());
  27. double amount = MAX_AMOUNT * Math.random();
  28. bank.transfer(fromAccount, toAccount, amount);
  29. Thread.sleep((int) (DELAY * Math.random()));
  30. }
  31. }
  32. catch (InterruptedException e)
  33. {
  34. }
  35. };
  36. Thread t = new Thread(r);
  37. t.start();
  38. }
  39. }
  40. }

运行结果:

测试程序2:

l 在Elipse环境下调试教材655页程序14-8,结合程序运行结果理解程序;

l 掌握synchronized在多线程同步中的应用。

代码:

  1. package synch2;
  2.  
  3. import java.util.*;
  4.  
  5. /**
  6. * A bank with a number of bank accounts that uses synchronization primitives.
  7. * @version 1.30 2004-08-01
  8. * @author Cay Horstmann
  9. */
  10. public class Bank
  11. {
  12. private final double[] accounts;
  13.  
  14. /**
  15. * Constructs the bank.
  16. * @param n the number of accounts
  17. * @param initialBalance the initial balance for each account
  18. */
  19. public Bank(int n, double initialBalance)
  20. {
  21. accounts = new double[n];
  22. Arrays.fill(accounts, initialBalance);
  23. }
  24.  
  25. /**
  26. * Transfers money from one account to another.
  27. * @param from the account to transfer from
  28. * @param to the account to transfer to
  29. * @param amount the amount to transfer
  30. */
  31. public synchronized void transfer(int from, int to, double amount) throws InterruptedException
  32. {
  33. while (accounts[from] < amount)
  34. wait();//导致线程进入等待状态直到它被通知。该方法只能在一个同步方法中调用。
  35. System.out.print(Thread.currentThread());//打印出线程号
  36. accounts[from] -= amount;
  37. System.out.printf(" %10.2f from %d to %d", amount, from, to);//第一个打印结果保留两位小数(最大范围是十位),
  38. accounts[to] += amount;
  39. System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
  40. notifyAll();//解除那些在该对象上调用wait方法的线程阻塞状态。该方法只能在同步方法或同步块内部调用。
  41. }
  42.  
  43. /**
  44. * Gets the sum of all account balances.
  45. * @return the total balance
  46. */
  47. public synchronized double getTotalBalance()
  48. {
  49. double sum = 0;
  50.  
  51. for (double a : accounts)
  52. sum += a;
  53.  
  54. return sum;
  55. }
  56.  
  57. /**
  58. * Gets the number of accounts in the bank.
  59. * @return the number of accounts
  60. */
  61. public int size()
  62. {
  63. return accounts.length;
  64. }
  65. }
  1. package synch2;
  2.  
  3. /**
  4. * This program shows how multiple threads can safely access a data structure,
  5. * using synchronized methods.
  6. * @version 1.31 2015-06-21
  7. * @author Cay Horstmann
  8. */
  9. public class SynchBankTest2
  10. {
  11. public static final int NACCOUNTS = 100;
  12. public static final double INITIAL_BALANCE = 1000;
  13. public static final double MAX_AMOUNT = 1000;
  14. public static final int DELAY = 10;
  15.  
  16. public static void main(String[] args)
  17. {
  18. Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
  19. for (int i = 0; i < NACCOUNTS; i++)
  20. {
  21. int fromAccount = i;
  22. Runnable r = () -> {
  23. try
  24. {
  25. while (true)
  26. {
  27. int toAccount = (int) (bank.size() * Math.random());
  28. double amount = MAX_AMOUNT * Math.random();
  29. bank.transfer(fromAccount, toAccount, amount);
  30. Thread.sleep((int) (DELAY * Math.random()));
  31. }
  32. }
  33. catch (InterruptedException e)
  34. {
  35. }
  36. };
  37. Thread t = new Thread(r);
  38. t.start();
  39. }
  40. }
  41. }

运行结果:

测试程序3:

l 在Elipse环境下运行以下程序,结合程序运行结果分析程序存在问题;

l 尝试解决程序中存在问题。

class Cbank

{

private static int s=2000;

public   static void sub(int m)

{

int temp=s;

temp=temp-m;

try {

Thread.sleep((int)(1000*Math.random()));

}

catch (InterruptedException e)  {              }

s=temp;

System.out.println("s="+s);

}

}

class Customer extends Thread

{

public void run()

{

for( int i=1; i<=4; i++)

Cbank.sub(100);

}

}

public class Thread3

{

public static void main(String args[])

{

Customer customer1 = new Customer();

Customer customer2 = new Customer();

customer1.start();

customer2.start();

}

}

存在的问题:

两个线程各自运行自己的

运行的预期结果应该为:

最终的s=1200

更正思路:

增加语句

synchronized

代码:

  1. package demo;
  2.  
  3. class Cbank
  4.  
  5. {
  6.  
  7. private static int s=2000;
  8.  
  9. public synchronized static void sub(int m)
  10.  
  11. {
  12.  
  13. int temp=s;
  14.  
  15. temp=temp-m;
  16.  
  17. try {
  18.  
  19. Thread.sleep((int)(1000*Math.random()));
  20.  
  21. }
  22.  
  23. catch (InterruptedException e) { }
  24.  
  25. s=temp;
  26.  
  27. System.out.println("s="+s);
  28.  
  29. }
  30.  
  31. }
  32.  
  33. class Customer extends Thread
  34.  
  35. {
  36.  
  37. public void run()
  38.  
  39. {
  40.  
  41. for( int i=1; i<=4; i++)
  42.  
  43. Cbank.sub(100);
  44.  
  45. }
  46.  
  47. }
  48.  
  49. public class Thread3
  50.  
  51. {
  52.  
  53. public static void main(String args[])
  54.  
  55. {
  56.  
  57. Customer customer1 = new Customer();
  58.  
  59. Customer customer2 = new Customer();
  60.  
  61. customer1.start();
  62.  
  63. customer2.start();
  64.  
  65. }
  66.  
  67. }

运行结果:

实验2 编程练习

利用多线程及同步方法,编写一个程序模拟火车票售票系统,共3个窗口,卖10张票,程序输出结果类似(程序输出不唯一,可以是其他类似结果)。

Thread-0窗口售:第1张票

Thread-0窗口售:第2张票

Thread-1窗口售:第3张票

Thread-2窗口售:第4张票

Thread-2窗口售:第5张票

Thread-1窗口售:第6张票

Thread-0窗口售:第7张票

Thread-2窗口售:第8张票

Thread-1窗口售:第9张票

Thread-0窗口售:第10张票

代码:

  1. package ThreadTest;
  2.  
  3. public class Demo {
  4. public static void main(String[] args) {
  5. Mythread mythread = new Mythread();
  6. Thread t1 = new Thread(mythread);
  7. Thread t2 = new Thread(mythread);
  8. Thread t3 = new Thread(mythread);
  9. t1.start();
  10. t2.start();
  11. t3.start();
  12. }
  13. }
  14.  
  15. class Mythread implements Runnable {
  16. int t = 1;
  17. boolean flag = true;
  18.  
  19. public void run() {
  20. // TODO Auto-generated method stub
  21. while (flag) {
  22. try {
  23. Thread.sleep(500);
  24. } catch (Exception e) {
  25. // TODO: handle exception
  26. e.printStackTrace();
  27. }
  28.  
  29. synchronized (this) {
  30. if (t <= 10) {
  31. System.out.println(Thread.currentThread().getName() + "窗口售:第" + t + "张票");
  32. t++;
  33. }
  34. if (t > 10) {
  35. flag = false;
  36. }
  37. }
  38.  
  39. }
  40. }
  41. }

运行结果:

代码:

  1. package ThreadTest;
  2.  
  3. public class Demo1 extends Thread {
  4. static int t = 1;
  5.  
  6. public void run() {
  7. synchronized (this) {
  8. while (t <= 10) {
  9. if (t <= 10) {
  10. System.out.println(Thread.currentThread().getName() + "窗口售:第" + t + "张票");
  11. t++;
  12. } else {
  13. System.out.println("票卖完了");
  14. }
  15. }
  16. try {
  17. sleep(500);
  18. } catch (InterruptedException e) {
  19. // TODO Auto-generated catch block
  20. e.printStackTrace();
  21. }
  22. }
  23. }
  24.  
  25. public static void main(String[] args) {
  26. Demo1 window1 = new Demo1();
  27. Demo1 window2 = new Demo1();
  28. Demo1 window3 = new Demo1();
  29. window1.start();
  30. window2.start();
  31. window3.start();
  32. }
  33.  
  34. }

运行结果:

王颖奇 20171010129《面向对象程序设计(java)》第十七周学习总结的更多相关文章

  1. 201771010134杨其菊《面向对象程序设计java》第九周学习总结

                                                                      第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...

  2. 201871010132-张潇潇《面向对象程序设计(java)》第一周学习总结

    面向对象程序设计(Java) 博文正文开头 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cn ...

  3. 扎西平措 201571030332《面向对象程序设计 Java 》第一周学习总结

    <面向对象程序设计(java)>第一周学习总结 正文开头: 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 ...

  4. 杨其菊201771010134《面向对象程序设计Java》第二周学习总结

    第三章 Java基本程序设计结构 第一部分:(理论知识部分) 本章主要学习:基本内容:数据类型:变量:运算符:类型转换,字符串,输入输出,控制流程,大数值以及数组. 1.基本概念: 1)标识符:由字母 ...

  5. 201871010124 王生涛《面向对象程序设计JAVA》第一周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://edu.cnblogs.com/campus/xbsf/ ...

  6. 201871010115——马北《面向对象程序设计JAVA》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  7. 201777010217-金云馨《面向对象程序设计(Java)》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  8. 201871010132——张潇潇《面向对象程序设计JAVA》第二周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  9. 201771010123汪慧和《面向对象程序设计Java》第二周学习总结

    一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言 ...

  10. 马凯军201771010116《面向对象与程序设计Java》第九周学习总结

    一.理论知识部分 异常.日志.断言和调试 1.异常:在程序的执行过程中所发生的异常事件,它中断指令的正常执行. 2.Java的异常处理机制可以控制程序从错误产生的位置转移到能够进行错误处理的位置. 3 ...

随机推荐

  1. stand up meeting 12/01/2015

    part 组员 今日工作 工作耗时/h 明日计划 工作耗时/h UI 冯晓云   赶工sprint3,各部分要合在一起时出现各种问题,各种修改测试:UI本身的功能继续实现完善    6 UWP对控件的 ...

  2. centos7 安装php7遇到的问题

    环境中安装过php 5.4,觉得版本太低了,因此删除旧版本安装了新版本 1. 安装epel-release 通过命令: rpm -ivh http://dl.fedoraproject.org/pub ...

  3. Scapy的基本使用

    关于Scapy Scapy是一个可以让用户发送.侦听和解析并伪装网络报文的Python程序.这些功能可以用于制作侦测.扫描和攻击网络的工具. 换言之,Scapy 是一个强大的操纵报文的交互程序.它可以 ...

  4. gojs去水印

    重点在go.js文件中将这个方法中的代码注释掉即可 搜索关键字 7ca11abfd022028846 然后注释下列代码,注释前先整理JS格式 function ni() { if(th) { var ...

  5. How to change the header background color of a QTableView

    You can set the style sheet on the QTableView ui->tableView->setStyleSheet("QHeaderView:: ...

  6. 基于docker-compose部署LNMP

    一.配置环境 [root@docker ~]# systemctl stop firewalld[root@docker ~]# iptables -F[root@docker ~]# setenfo ...

  7. C6 C7的开机启动流程

    C6开机启动流程 1.内核引导,加电自检(通电后检查内核):检查bios的配置,检测硬件 装好系统之后才会进行以下内容 MBR 引导 (3.2.1...) GRUB菜单 (选择不同的系统)(按e,进入 ...

  8. 【DNS域名解析命令】 nslookup

    1. nslookup作用 nslookup用于查询DNS的记录,查询域名解析是否正常,在网络故障时用来诊断网络问题 nslookup - query Internet name servers in ...

  9. Kubernetes 持久化存储是个难题,解决方案有哪些?\n

    像Kubernetes 这样的容器编排工具正在彻底改变应用程序的开发和部署方式.随着微服务架构的兴起,以及基础架构与应用程序逻辑从开发人员的角度解耦,开发人员越来越关注构建软件和交付价值. Kuber ...

  10. Math.Round和四舍五入

    Math.Round方法并不是像想象中的四舍五入, 可以从下面的输出结果看出来: Math.Round(3.44, 1); //Returns 3.4. Math.Round(3.45, 1); // ...