계획 |
함유량 |
이 작품은 과정 속 |
|
어디에서 작업이 요구 사항 |
https://www.cnblogs.com/nwnu-daizh/p/12073034.html |
작업 학습 목표 |
(1) 이해 속성 및 우선 순위 스케줄링 방법 스레드 마스터; (2) 개념과 스레드 동기화 기술의 구현을 파악하는 단계; (3) 자바는 포괄적 인 프로그래밍 연습 스레드 |
파트 I : 스레드 동기화 기술의 개요
스레드 동기화는 무엇입니까?
우리는 이러한 문제를 해결하기 위해 동기화 메커니즘을 사용하므로 다중 스레드 (예 : 여러 스레드가 일치하지 않는 데이터에 동일한 데이터 리드에서 운영하는 등) 문제 - 안전 스레드에 매우 경향이 동일한 데이터를 액세스 할 때.
스레드의 주
스레드의 상태가 시간과 작업의 일정 기간의 활성 스레드가 수행되어야 나타냅니다. 준비가 만든 스레드가있다, 차단, 실행, 다섯 개 가지 상태 중 하나에 항상. 오 개 상태를 사망 삶의 스레드를 가지고 있습니다.
상태를 만들기 (1)
스레드 객체의 예,하지만 메서드 호출을 명시하지 않는 시작 (). 일예로
ThreadTest로 시험을 ThreadTest 새로운을 () =; //或者 스레드 t 새로운 스레드 (테스트) =;
스레드 객체가 생성되지만이 때,하지만 일시적으로 isAlive () 테스트를 통과 할 수 없습니다.
2. 준비
3. 실행 상태
t.start(); t.start();
这是错误的用法
注意:线程的启动要调用start()方法,只有这样才能创建新的调用栈.而直接调用run()方法的话,就不会创建新的调用栈,也就不会创建新的线程,run()方法就普通方法没什么两样了.
Thread类实现了Runnable
线程同步
1.共享变量
要使多个线程在一个程序中有用,必须有某种方法实现线程间的互相通信或共享结果,最简单的方法是使用共享变量.使用同步来确保值从一个线程正确传播到另一个线程,以及防止当一个线程正在更新一些相关数据项时,另一个线程看到不一致的中间结果.
2.存在于同一内存空间中的所有线程
线程与进程有许多共同点,不同的是线程与同一进程中的其他线程共享相同进程上的下文,包括内存空间,只要访问共享变量(静态或者实例变量),线程就可以方便地互相交换数据,但必须确保线程以受控的方式访问共享变量,以免它们互相干扰对方的更改.
3.受控访问的同步
为了确保可以在线程之间以受控方式共享数据,Java语言提供了两个关键字:synchronized和volatile.
synchronized有两个重要的含义
synchronized(对象) { // 任意对象都可以。这个对象就是锁。 需要被同步的代码; } public synchronized void transfer() { }
private volatile double balance;
6.Java锁定
Java锁定可以保护许多代码块或方法,每次只有一个线程可以持有锁.
反之,仅仅因为代码块由锁保护并不代表两个线程不能同时执行该代码块.它只表示如果两个线程正在等待相同的锁,则它们不能同时执行该代码.
7.同步的方法
创建synchronized 块的最简单方法是将方法声明成synchronized.这表示在进入方法主体之前,调用者必须获得锁.示例代码如下:
public class Point{ public synchronized void setXY(int x,int y){ this.x = x; this.y = y; } }
public class Point{ public synchronized void setXY(int x,int y){ this.x = x; this.y = y; } }
9.同步的块
public class Point{ public synchronized void setXY(int x,int y){ synchronized (this) { this.x = x; this.y = y; } } }
10.大多数类并没有同步
因为同步会带来小小的性能损失,大多数通用类,如java.util中的Collection类,不在内部使用同步,这表示在没有附加同步的情况下,不能在多个线程中使用诸如HashMap这样的类.
Lock显示锁
java从1.5版本之后,提供了Lock接口。这时候,直接将锁封装成了对象。线程进入同步就是具备了锁,执行完,离开同步,就是释放了锁。在后期对锁的分析过程中,发现,获取锁,或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中,并把锁定义成对象。所以,同步是隐式的锁操作,而Lock对象是显示的锁操作。
bankLock.lock(); //a ReentrantLock object try { //临界区 } finally { bankLock.unlock(); //如果在临界区抛出异常,必须保证锁被释放 }
另外,有一个需要注意的地方是,锁的唤醒机制的不同。
在用同步synchronized来实现加锁时,由于这时的锁用的是任意对象,所以如wait,notify,notifyAll等操作锁的等待唤醒的方法都定义在Object中。
而现在用Lock时,用的锁是Lock对象。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法,而是将这些方式又单独封装到了一个对象中。这个对象就是Condition,将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。
下面是java核心技术卷1中关于显示锁核心代码:
/** * 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 void transfer(int from, int to, double amount) throws InterruptedException { bankLock.lock(); try { while (accounts[from] < amount) sufficientFunds.await(); System.out.print(Thread.currentThread()); 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()); sufficientFunds.signalAll(); } finally { bankLock.unlock(); } }
这里使用一个锁来保护Bank中的transfer方法,模拟现实中转账操作。
假定一个线程调用transfer时,在执行结束前被剥夺了运行权。假定第二个线程也调用transfer,由于第二个线程不能获得锁,将在调用lock方法时被阻塞。它必须等待第一个线程完成transfer方法的执行之后才能再度激活。当第一个线程释放锁时,那么第二个线程才可以运行。
锁是可重入的,因为线程可以重复地获得已经持有的锁。锁保持一个持有计数来跟踪对lock方法的嵌套调用。线程在每一次调用lock都要使用unlock来释放锁。由于这一特性,被一个锁保护的代码可以调用另一个使用相同的锁的方法。例如,当transfer方法调用getTotalBalance方法,这也会封锁bankLock对象,此时bankLock持有的计数为2.当getTotalBalance方法退出是,持有计数变为1.当transfer方法退出的时候,持有的计数变为0.线程释放锁。上面实例代码中调用的方法getTotalBalance与transfer方法使用的是同一个锁。
/** * Gets the sum of all account balances. * @return the total balance */ public double getTotalBalance() { bankLock.lock(); try { double sum = 0; for (double a : accounts) sum += a; return sum; } finally { bankLock.unlock(); } }
另外,上面的案列使用显示锁Lock,同样可以用同步的方法来实现,将transfer方法用synchronized修饰,同样在transfer中调用的getTotalBalance也需要用synchronized来修饰。
/** * 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 { while (accounts[from] < amount) wait(); System.out.print(Thread.currentThread()); 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(); } /** * 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; }
二、实验内容和步骤
实验1:测试程序并进行代码注释。
测试程序1:
l 在Elipse环境下调试教材651页程序14-7,结合程序运行结果理解程序;
l 掌握利用锁对象和条件对象实现的多线程同步技术。
程序:
package synch; import java.util.*; import java.util.concurrent.locks.*; /** *一种拥有许多银行帐户的银行,它使用锁来序列化访问。 * @version 1.30 2004-08-01 * @author Cay Horstmann */ public class Bank { private final double[] accounts;//银行运转的基础数据 private Lock bankLock;//锁对象 private Condition sufficientFunds; /** * 构建银行。 * @param 账户数量 * @param 每个帐户的初始余额 */ public Bank(int n, double initialBalance) { accounts = new double[n]; Arrays.fill(accounts, initialBalance);//调用initialBalance生成锁对象属性 bankLock = new ReentrantLock(); sufficientFunds = bankLock.newCondition(); } /** * 把钱从一个账户转到另一个账户。 * @param 从该账户转账 * @param 把钱转到账户上 * @param 转帐金额 */ //transfer方法 public void transfer(int from, int to, double amount) throws InterruptedException {//通过锁对象生成条件对象 bankLock.lock();//加锁 try { while (accounts[from] < amount) sufficientFunds.await();//条件对象如果被注释会出现死锁现象不能实现线程的有效调用 System.out.print(Thread.currentThread()); 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()); sufficientFunds.signalAll();//调用signalAll()方法 } finally { bankLock.unlock(); } } /** * 获取所有帐户余额的总和。 * @return the total balance */ public double getTotalBalance() { bankLock.lock();//加锁 try { double sum = 0; for (double a : accounts) sum += a; return sum; } finally { bankLock.unlock();//解锁 } } /** * 获取银行帐户的数目。 * @return 账户数量 */ public int size() { return accounts.length; } }
package synch; /** * 这个程序演示了多线程如何安全访问一个数据结构。 * @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.*; /** * 使用同步原语的具有多个银行帐户的银行 * @version 1.30 2004-08-01 * @author Cay Horstmann */ public class Bank { private final double[] accounts; /** * 构建了银行。 * @param 账户数量 * @param 每个账户的初始余额 */ public Bank(int n, double initialBalance) { accounts = new double[n]; Arrays.fill(accounts, initialBalance); } /** * 把钱从一个账户转到另一个账户。 * @param 从账户转出 * @param 到账转到 * @param 转帐金额 */ public synchronized void transfer(int from, int to, double amount) throws InterruptedException { while (accounts[from] < amount) wait();//使线程处于等待集中 System.out.print(Thread.currentThread()); 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();//唤醒所有等待的线程 } /** * 获取所有帐户余额的总和。 * @return 总平衡 */ public synchronized double getTotalBalance() { double sum = 0; for (double a : accounts) sum += a; return sum; } /** * 获取银行中的帐户编号。 * @return 账户数量 */ public int size() { return accounts.length; } }
package synch2; /** * 这个程序展示了多线程如何安全地访问一个数据结构,使用同步方法。 * @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; 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();//线程处于可运行状态 } } }
运行结果:
测试程序3:
l 在Elipse环境下运行以下程序,结合程序运行结果分析程序存在问题;
l 尝试解决程序中存在问题。
class Cbank { private static int s=2000;//当类加载时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();//把变量customer1的值设置为分配给新的Customer对象的内部地址 Customer customer2 = new Customer(); customer1.start(); customer2.start(); } }
运行结果:
修改后代码:
package Thread; 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张票
程序设计思路简述:
首先创建一个售票的一个线程组,其有3个线程售票,然后通过传递sellTicketThreadGroud参数给一个新的线程,重写run方法,执行sell方法,其中sell方法是使用 synchronized 关键字来修饰的,其确保在一个时刻只有一个线程可以进入sell方法执行代码。
结对编程者:吴丽丽
public class SellTickets3 { private static int tickets = 1; // 使用 synchronized 关键字修饰方法,确保某一时刻只有一个线程能够进入该方法中执行代码 protected synchronized static void sell() {
if (tickets <= 10) { System.out.println(Thread.currentThread().getName() + " 窗口售:第 " + tickets++ + " 张票"); } } public static void startSell() { // 售票线程所在线程组 ThreadGroup sellTicketThreadGroup = new ThreadGroup("sell ticket thread group"); // 开启 3 个线程售票 for (int i = 0; i < 3; i++) { // 新建售票线程,并将其加入售票线程组中 new Thread(sellTicketThreadGroup, "Thread-" + (i)) { @Override public void run() { while (tickets > 0) { sell(); try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO 自动生成的 catch 块 e.printStackTrace(); } } } }.start(); } } public static void main(String[] args) { SellTickets3.startSell(); } }
运行结果:
实验总结:
这周继续学习了有关线程的知识,主要学习了有关线程同步的问题。线程同步主要是为了解决多线程并发运行不确定性问题,使得多个线程中在一个线程使用某种方法时候,另一线程要使用该方法,就只能等待。在实验中学会了在Java中解决多线程同步问题。掌握利用锁对象和条件对象实现的多线程同步技术。掌握synchronized在多线程同步中的应用。