关键词:
201871010111-刘佳华《面向对象程序设计(java)》第十七周学习总结
实验十七 线程同步控制
实验时间 2019-12-20
第一部分:理论知识总结
16.Java 的线程调度采用优先级策略:
优先级高的先执行,优先级低的后执行;
多线程系统会自动为每个线程分配一个优先级,缺省时,继承其父类的优先级;
任务紧急的线程,其优先级较高; 同优先级的线程按“先进先出”的队列原则。
调用setPriority(int a)重置当前线程的优先级,a取值可以是前述的三个静态量。
调用getPriority()获得当前线程优先级。
多线程并发运行不确定性问题解决方案:引入线程同步机制,使得另一线程要使用该方法,就只能等待。
在Java中解决多线程同步问题的方法有两种:Java SE 5.0中引入ReentrantLock类。 在共享内存的类方法前加synchronized修饰符。
用ReentrantLock保护代码块的基本结构如下:
myLock.lock();
try
critical section
finally
myLock.unlock();
有关锁对象和条件对象的关键要点:
1.锁用来保护代码片段,保证任何时刻只能有一个线程执行被保护的代码。
2.锁管理试图进入被保护代码段的线程。
3.锁可拥有一个或多个相关条件对象。
4.每个条件对象管理那些已经进入被保护的代码 段但还不能运行的线程。
synchronized关键字作用: 某个类内方法用synchronized 修饰后,该方法被称为同步方法;只要某个线程正在访问同步方法,其他线程欲要访问同步方法就被阻塞,直至线程从同 步方法返回前唤醒被阻塞线程,其他线程方可能进入同步方法。
在同步方法中使用wait()、notify 和notifyAll()方法:
一个线程在使用的同步方法中时,可能根据问题的需要,必须使用wait()方法使本线程等待,暂时让出CPU的使用权,并允许其它线程使用这个同步方法。
线程如果用完同步方法,应当执行notifyAll()方法通知所有由于使用这个同步方法而处于等待的线程结束等待。
第二部分:实验部分
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 /**与同步控制有关的类对象*/
15 private Lock bankLock; //lock对象
16 private Condition sufficientFunds;//condition对象
17
18 /**
19 * Constructs the bank.
20 * @param n the number of accounts
21 * @param initialBalance the initial balance for each account
22 */
23 public Bank(int n, double initialBalance)
24
25 accounts = new double[n];
26 Arrays.fill(accounts, initialBalance); //数组account的填充
27 bankLock = new ReentrantLock();
28 sufficientFunds = bankLock.newCondition();
29
30
31 /**
32 * Transfers money from one account to another.
33 * @param from the account to transfer from
34 * @param to the account to transfer to
35 * @param amount the amount to transfer
36 */
37 public void transfer(int from, int to, double amount) throws InterruptedException //模拟行内转账操作
38
39 bankLock.lock(); //加锁操作
40 try
41
42 while (accounts[from] < amount)
43 sufficientFunds.await(); //阻塞事件队列
44 System.out.print(Thread.currentThread());
45 accounts[from] -= amount;
46 System.out.printf(" %10.2f from %d to %d", amount, from, to);
47 accounts[to] += amount;
48 System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
49 sufficientFunds.signalAll();//唤醒所有线程
50
51 finally
52
53 bankLock.unlock(); //解除锁操作
54
55
56
57 /**
58 * Gets the sum of all account balances.
59 * @return the total balance
60 */
61 public double getTotalBalance()
62
63 bankLock.lock();
64 try
65
66 double sum = 0;
67
68 for (double a : accounts)
69 sum += a;
70
71 return sum;
72
73 finally
74
75 bankLock.unlock();
76
77
78
79 /**
80 * Gets the number of accounts in the bank.
81 * @return the number of accounts
82 */
83 public int size()
84
85 return accounts.length;
86
87
package synch;
/**
* This program shows how multiple threads can safely access a data structure.
* @version 1.31 2015-06-21
* @author Cay Horstmann
*/
public class SynchBankTest
public static final int NACCOUNTS = 100;
public static final double INITIAL_BALANCE = 1000;
public static final double MAX_AMOUNT = 1000;
public static final int DELAY = 10;
public static void main(String[] args)
Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
for (int i = 0; i < NACCOUNTS; i++)
int fromAccount = i;
Runnable r = () ->
try
while (true)
int toAccount = (int) (bank.size() * Math.random());
double amount = MAX_AMOUNT * Math.random();
bank.transfer(fromAccount, toAccount, amount);
Thread.sleep((int) (DELAY * Math.random()));//随机生成时间,使正在执行的线程休眠
catch (InterruptedException e)
;
Thread t = new Thread(r);
t.start();
运行截图:
测试程序2:
l 在Elipse环境下调试教材655页程序14-8,结合程序运行结果理解程序;
l 掌握synchronized在多线程同步中的应用。
package synch2;
import java.util.*;
/**
* A bank with a number of bank accounts that uses synchronization primitives.
* @version 1.30 2004-08-01
* @author Cay Horstmann
*/
public class Bank
private final double[] accounts;
/**
* Constructs the bank.
* @param n the number of accounts
* @param initialBalance the initial balance for each account
*/
public Bank(int n, double initialBalance)
accounts = new double[n];
Arrays.fill(accounts, initialBalance);
/**
* Transfers money from one account to another.
* @param from the account to transfer from
* @param to the account to transfer to
* @param amount the amount to transfer
*/
public synchronized void transfer(int from, int to, double amount) throws InterruptedException//sysynchronized关键字修饰方法实现加锁操作
while (accounts[from] < amount)
wait(); //wait()方法导致线程进入等待状态直到它被通知,该方法只能在一个同步方法中调用
System.out.print(Thread.currentThread());//Thread.currentThread()返回当前执行线程的Thread对象
accounts[from] -= amount;
System.out.printf(" %10.2f from %d to %d", amount, from, to);
accounts[to] += amount;
System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
notifyAll(); //解除那些在该对象上调用wait方法的线程的阻塞状态
/**
* Gets the sum of all account balances.
* @return the total balance
*/
public synchronized double getTotalBalance()
double sum = 0;
for (double a : accounts)
sum += a;
return sum;
/**
* Gets the number of accounts in the bank.
* @return the number of accounts
*/
public int size()
return accounts.length;
package synch2;
/**
* This program shows how multiple threads can safely access a data structure,
* using synchronized methods.
* @version 1.31 2015-06-21
* @author Cay Horstmann
*/
public class SynchBankTest2
public static final int NACCOUNTS = 100;
public static final double INITIAL_BALANCE = 1000;
public static final double MAX_AMOUNT = 1000;
public static final int DELAY = 10;
public static void main(String[] args)
Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
for (int i = 0; i < NACCOUNTS; i++)
int fromAccount = i;
/**lamber表达式*/
/*Runnable r = () ->
try
while (true)
int toAccount = (int) (bank.size() * Math.random());
double amount = MAX_AMOUNT * Math.random();
bank.transfer(fromAccount, toAccount, amount);
Thread.sleep((int) (DELAY * Math.random()));
catch (InterruptedException e)
;*/
/**直接声明
* Runnable r=new Runnable()
@Override
public void run()
try
while (true)
int toAccount = (int) (bank.size() * Math.random());
double amount = MAX_AMOUNT * Math.random();
bank.transfer(fromAccount, toAccount, amount);
Thread.sleep((int) (DELAY * Math.random()));
catch (InterruptedException e)
;
;*/
/**
* 匿名内部类
*/
Thread t = new Thread(new Runnable()
@Override
public void run()
try
while (true)
int toAccount = (int) (bank.size() * Math.random());
double amount = MAX_AMOUNT * Math.random();
bank.transfer(fromAccount, toAccount, amount);
Thread.sleep((int) (DELAY * Math.random()));
catch (InterruptedException e)
;
);
t.start();
运行结果:
测试程序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();
|
源代码运行截图:
会发现源代码运行结果错误;这是由于多线程并发执行过程(两个或者两个以上的线程共享某个对象,每一个对象都调用该对象的状态方法)中存在问题:
1.多线程的相对执行顺序不确定
2.执行顺序的不确定会产生执行结果的不确定性
3.在多线程对于共享数据的操作时常常会产生不确定性
修改后代码(采用关键字synchronized修饰方法修改程序)
package op;
class Cbank
private static int s=2000;
public synchronized 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();
运行截图:
实验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.设计思路:出票时三个窗口并行造作,可抽象为三个线程并行占用cpu,可以利用关键字synchronized使得实现并发操作。
2.对synchronized(this)的一些理解
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
五、以上规则对其它对象锁同样适用.
3.整体实验代码:
package TeamWork06;
class Ticketsthread implements Runnable
public static final int DELAY = 1000;
int t = 1;
boolean flag = true;
public void run()
while (flag)
try
Thread.sleep((int) (DELAY * Math.random()));
catch (InterruptedException e)
e.printStackTrace();
synchronized (this)
if (t <= 10)
System.out.println(Thread.currentThread().getName() + "窗口售:第" + t + "張票");
t++;
if (t > 10)
flag = false;
public class TicketsTest
public static void main(String[] args)
Ticketsthread th = new Ticketsthread();
new Thread(th).start();
new Thread(th).start();
new Thread(th).start();
运行截图:
第三部分:实验心得
通过本周的学习,了解到了解决多线程同步问题的两种方法:ReentrantLock类和synchronized修饰符,理解了其使用方法,能够使用简单的编程实现方法的使用来处理并发问题.在实验课上收获了当注释调代码sufficientFunds.await();会出现死锁状态等知识,感受颇多。注意点有:线程如果用完同步方法,应当执行notifyAll()方 法通知所有由于使用这个同步方法而处于等待的 线程结束等待。线程如果用完同步方法,应当执行notifyAll()方 法通知所有由于使用这个同步方法而处于等待的 线程结束等待。以后会坚持学习Java。
alphascrummeeting6
...和修复。6.2成员贡献时间姓名贡献时间(小时)常龙龙2.8刘佳华2.8陈荟茹2.8陈鑫莲2.86.3明天任务安排姓名任务常龙龙组织协调任务进度,学习WBS,了解并 查看详情
面向对象程序设计介绍以及面向对象的基本特征
面向对象的程序设计(ObjectOrientedProgramming,OOP)方法是目前比较流行的程序设计方法,和面向过程的程序设计比,它更符合人类的自然思维方式。在面向过程程序设计中,程序=数据+算法,数据和对数据的操作是分离的,如... 查看详情
《面向对象程序设计概述》牛咏梅
面向对象程序设计概述牛咏梅(南阳理工学院河南南阳473000)摘要:分析传统程序设计方法与面向对象程序设计方法之间的差别,重点分析了面向对象程序设计方法的特点,介绍了面向对象程序设计方法的步骤及其优点。关键词:面向对... 查看详情
java面向对象大致梳理
...概述:Java设计语言面向对象:Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物,每种事物都... 查看详情
面向对象的程序设计
阅读目录一面向对象的程序设计的由来二什么是面向对象的程序设计及为什么要有它三类与对象四属性查找五绑定到对象的方法的特殊之处六对象之间的交互七练习八继承与派生九多态与多态性十封装十一绑定方法与非绑定方法... 查看详情
面向对象思想
...0年代,位于美国加州的Xerox研究中心推出smalltalk语言及其程序设计环境,使得面向对象程序设计方法得到比较完善的实现,掀起了面向对象研究的高潮。到80年代中后期,面向对象的软件设计和程序设计方法 查看详情
面向对象设计----软件设计师
上午12分下午两大答题30分面向对象的基本概念❤❤❤❤❤采用面向对象的软件开发,通常由面向对象分析,面向对象设计,面向对象实现1面向对象分析OOA:获取对应用问题的理解,主要任务是抽取和整理用户需求并建立问题域精确模... 查看详情
面向对象分析与设计面向对象设计包括哪些内容
一、总述面向对象分析的输入是用户的功能需求,输出是简单的、理性化的分析模型,此阶段的工作更多侧重于如何理解软件的功能需求;面向对象设计的输入是面向对象分析的结果,蔬菜水果最终的、细化后的设计模型,此阶... 查看详情
面向对象思想初识
面向对象思想概述Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物,每种事物都具备自己的... 查看详情
面向过程程序设计,面向对象程序设计,可视化程序设计的异同
...开-闭原则。也使代码更易阅读。相对而言,面向过程的程序设计是面向对象程序设计的基础。面向对象的程序里面一定会有面向过程的程序片断的!可视化程序设计主要是一种技术 参考技术B这些是阶梯型向上发展的,一个比一... 查看详情
面向对象程序设计的总结
自学习面向对象程序设计语言以来,深深体会到这种语言的魅力。与面向过程设计语言相比,随着学习的深入,两者的风格不一更加凸显。面向过程程序设计语言,典型的有C语言、C++,面向过程是一种以过程... 查看详情
面向对象的程序设计(代码片段)
一、什么是面向对象 面向对象编程是一种编程方式,使用“类”和“对象”来实现,所以,面向对象编程就是对“类”和“对象”的使用。 面向对象编程核心就是“对象”二字,“对象”是特征与技能的结合体。“类”... 查看详情
面向对象简述
一、面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++... 查看详情
[6]面向对象编程
...面向对象编程——ObjectOrientedProgramming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行... 查看详情
面向对象(代码片段)
阅读目录一面向对象的程序设计的由来二什么是面向对象的程序设计及为什么要有它三类与对象四属性查找五绑定到对象的方法的特殊之处六对象之间的交互七练习八继承与派生九多态与多态性十封装十一绑定方法与非绑定方法... 查看详情
面向对象
一面向对象的程序设计的由来二什么是面向对象的程序设计及为什么要有它三类与对象四属性查找五绑定到对象的方法的特殊之处六对象之间的交互七练习八继承与派生九多态与多态性十封装十一绑定方法与非绑定方法十二小白... 查看详情
面向对象
一面向对象的程序设计的由来面向对象设计的由来见概述:http://www.cnblogs.com/linhaifeng/articles/6428835.html 二什么是面向对象的程序设计及为什么要有它面向过程的程序设计:核心是过程二字,过程指的是解决问题的步骤,即先... 查看详情
面向对象编程——概论
面向对象编程——ObjectOrientedProgramming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。 面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执... 查看详情