您的位置：首页 > 编程语言 > Java开发

201521123122 《java程序设计》第十一周学习总结

2017-05-06 18:34 232 查看

## 201521123122 《java程序设计》第十一周实验总结 ##

1. 本周学习总结

1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。

其实这周也没讲多少内容，所以思维导图画的也比较简单。我在这里在总结一下:

1.如果有多个线程需要对同一个数据进行存取时，一定要考虑互斥的情况。

2.关于synchronized的用法：

synchronized有两种用法，第一种是代表原子操作的程序代码前加上synchronized标记,第二种是使用synchronized代码块。如

public static synchronized void addId() {
id++;
}//第一种方法
public static void addId() {
synchronized (Counter.class) {//代表Counter类型的对象
id++;
}
}//第二种方法

3.synchronized的作用：在java中，每个对象都有一把对象锁，只有获得对象的对象锁，才能执行此功能，而synchronized的作用在于把对象的对象锁“夺”过来，让自己执行此功能，而其他线程无法执行。（不知道这样理解对不对- -）。

4.关于多线程的同步问题:我的理解就是对于同一个数据，某个线程向其存储的速度和另外一个线程向其读取数据的速度不同，所以要通过wait () 和notify()/notifyAll()来控制。

5.关于wait () 和notify()/notifyAll()的用法：

wait()方法的作用就是让其线程释放被其“夺走”的对象锁，然后进入wait队列。notify（）的作用就是再让进入wait队列的线程重新移入等待同一个“对象互斥锁”的队列。因为这两个方法都和“对象锁”有关，所以他们只能在声明为synchronized的代码中调用。

本次PTA作业题集多线程

互斥访问与同步访问

完成题集4-4(互斥访问)与4-5(同步访问)

1.1 除了使用synchronized修饰方法实现互斥同步访问，还有什么办法实现互斥同步访问（请出现相关代码）？

利用lock对象，代码如下：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumerTestWithLock {

public static void main(String[] args) {
ProducerConsumerPool pool = new ProducerConsumerPool();
ProducerConsumerPool.Producer p1 = pool.new Producer();
ProducerConsumerPool.Consumer c1 = pool.new Consumer();
Thread t1 = new Thread(p1);
Thread t2 = new Thread(c1);
t1.start();
t2.start();
System.out.println("Starting!");
}
}

class ProducerConsumerPool{
private Lock poolLock = new ReentrantLock();//建一个lock对象
private static final int ITEMS = 1000;
private int count=0;
public  int  getCount(){
return count;
}
public  void setCount(int i){
count = i;
}
public  void produce(){
poolLock.lock();//实现互斥访问
setCount(getCount()+1);
poolLock.unlock();//
}
public  void consume(){
poolLock.lock();//实现互斥访问
setCount(getCount()-1);
poolLock.unlock();//
}

public class Producer implements Runnable {
public void run() {
for (int i = 0; i < ITEMS; i++)
produce();
System.out.println(Thread.currentThread().getName()+" produed "+ITEMS+ " now the count is "+count);
}
}

public class Consumer implements Runnable {
public void run() {
for (int i = 0; i < ITEMS; i++)
consume();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" consumed "+ITEMS+ " now the count is "+count);
}
}
}

Lock和synchronized的区别

1.2 同步代码块与同步方法有何区别？

以下转自链接：https://www.nowcoder.com/questionTerminal/08ee355c9e7948ed9afbcf9a0d19998d

为何要使用同步？java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查),将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用,从而保证了该变量的唯一性和准确性.1.同步方法,即有synchronized关键字修饰的方法.由于java的每个对象都有一个内置锁，当用此关键字修饰方法时,内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态.代码如：

public synchronized void save(){}

注：synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类2.同步代码块。即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

代码如:

synchronized(object){}

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

总结来说就是，同步方法是对整个方法用内部锁修饰，而同步代码块只是对某段代码进行修饰，范围上看，是同步方法的范围较大些，但是就如上文所说，如果没有必要同步整个方法时，同步关键代码块是一个较好的选择。

1.3 实现互斥访问的原理是什么？请使用对象锁概念并结合相应的代码块进行说明。当程序执行synchronized同步代码块或者同步方法时，线程的状态是怎么变化的？

先谈什么是对象锁，说是对象锁，但我个人更喜欢把它比喻成钥匙，只有拥有对象锁的线程，才能获得这个对象的执行权利，首先一个对象只拥有一把对象锁，当多个线程同时访问这个对象时，就意味着多个线程同时争这个对象锁，这时被synchronized修饰的首先拥有了对象锁，这时只有他能访问其对象，其他人只能等他访问结束后在继续争其对象锁。

线程的状态变化：多个线程运行->多个线程竞争对象锁->一个线程获得对象锁运行，其余等待->一个线程结束，其余线程竞争对象锁->直到所有线程运行结束。

1.4 Java多线程中使用什么关键字实现线程之间的通信，进而实现线程的协同工作？为什么同步访问一般都要放到synchronized方法或者代码块中？

1.使用wait()和nitify()关键字实现。

2.wait()方法的作用就是让其线程释放被其“夺走”的对象锁，然后进入wait队列。nitify（）的作用就是再让进入wait队列的线程重新移入等待同一个“对象互斥锁”的队列。因为这两个方法都和“对象锁”有关，所以他们只能在声明为synchronized的代码中调用。

交替执行

实验总结（不管有没有做出来）

实现交替访问关键是利用好Boolean变量，因为Boolean变量只有True和FALSE两个值，当每次执行完一个线程是，改变Boolean的值就可实现交替执行。关键代码如下：

public synchronized void run1() {
while (!flag) {
try {
wait();
} catch (Exception e) {
e.printStackTrace();
}

}
if (getSize() > 0) {
flag = false;
System.out.println(Thread.currentThread().getName() + " finish " + task[i++]);
notify();
}
}

public synchronized void run2() {
while (flag) {
try {
wait();
} catch (Exception e) {
e.printStackTrace();
}

}
if (getSize() > 0) {
flag = true;
System.out.println(Thread.currentThread().getName() + " finish " + task[i++]);
notify();
}
}

}

还要注意的是把传递进来的字符串以空格区分分解为多个不同的任务要用split方法，每次执行完线程后，要删除这个任务，所以public int getSize() 时要返回task.length - i。