201871010131-张兴盼《面向对象程序设计（java）》第十七周学习总结

项目	内容
《面向对象程序设计（java）》	https://home.cnblogs.com/u/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/12073034.html
作业学习目标	(1) 理解和掌握线程的优先级属性及调度方法； (2) 掌握线程同步的概念及实现技术； (3) Java线程综合编程练习

第一部分：总结线程同步技术

1.多线程的概念：

（1）多线程是进程执行过程中产生的多条执行线索。 

（2）多线程意味着一个程序的多行语句可以看上去几 乎在同一时间内同时运行。 

（3）线程不能独立存在，必须存在于进程中，同一进 程的各线程间共享进程空间的数据。 

2.Java实现多线程有两种途径：
创建Thread类的子类
在程序中定义实现Runnable接口的类

3.用Thread类的子类创建线程：

（1）首先需从Thread类派生出一个子类，在该子类中 重写run()方法。 

例： class hand extends Thread {

public void run() {……}

}

（2） 然后用创建该子类的对象 

Lefthand left=new Lefthand();

Righthand right=new Righthand(); 

（3）最后用start()方法启动线程 

left.start();

right.start();

4.用Thread类的子类创建多线程的关键性操作：

（1）定义Thread类的子类并实现用户线程操作，即 run()方法的实现。

（2）在适当的时候启动线程。

由于Java只支持单重继承，用这种方法定义的类不 可再继承其他父类。

用Runnable()接口实现线程

（1）首先设计一个实现Runnable接口的类； 

（2） 然后在类中根据需要重写run方法； 

（3）再创建该类对象，以此对象为参数建立Thread 类的对象； 

（4）调用Thread类对象的start方法启动线程，将 CPU执行权转交到run方法。

5.被阻塞线程和等待线程

 blocked (被阻塞)：

阻塞时线程不能进入队列排队，必须等到引起 阻塞的原因消除，才可重新进入排队队列。 

sleep(),wait()是两个常用引起线程阻塞的方法。

6.线程阻塞的三种情况：

（1）等待阻塞 ：通过调用线程的wait()方法，让线 程等待某工作的完成。 

（2）同步阻塞 ：线程在获取synchronized同步锁失 败(因为锁被其它线程所占用)，它会进入同步阻 塞状态。 

（3）其他阻塞 ：通过调用线程的sleep()或join() 或发出了I/O请求时，线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超 时、或者I/O处理完毕时，线程重新转入就绪状态。

7.被终止的线程

 Terminated (被终止) 线程被终止的原因有二： 

（1）一是run()方法中最后一个语句执行完毕而自 然死亡。 

（2）二是因为一个没有捕获的异常终止了run方法 而意外死亡。 

可以调用线程的stop 方 法 杀 死 一 个 线 程 （thread.stop();)，但是，stop方法已过时， 不要在自己的代码中调用它。

8.其他判断和影响线程状态的方法：

（1）join()：等待指定线程的终止。 

（2）join(long millis)：经过指定时间等待终止指定 的线程。 

（3）isAlive()：测试当前线程是否在活动。 

（4）yield()：让当前线程由“运行状态”进入到“就 绪状态”，从而让其它具有相同优先级的等待线程 获取执行权。

9.多线程调度

（1）Java提供一个线程调度器来监控程序启动后进入可运行状态的所有线程。线程调度器按照线程的优先级决定应调度哪些线程来执行。

（2）处于可运行状态的线程首先进入就绪队列排队等候处理器资源，同一时刻在就绪队列中的线程可能有多个。Java的多线程系统会给每个线程自动分配一个线程的优先级。

 10.Java 的线程调度采用优先级策略:

（1）优先级高的先执行，优先级低的后执行；

（2）多线程系统会自动为每个线程分配一个优先级，缺省时，继承其父类的优先级；

（3）任务紧急的线程，其优先级较高；

（4）同优先级的线程按“先进先出”的队列原则；

11.守护线程

守护线程的惟一用途是为其他线程提供服务。例 如计时线程。

在一个线程启动之前，调用setDaemon方法可 将线程转换为守护线程（daemon thread）。 例如： setDaemon(true);

12.要实现线程同步的原因： 

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时， 
会产生冲突，使得变量值不唯一，因此我们需要加入同步锁来避免在当前线程的操作未完成前，其它线程改变共享资源值的情况发生，从而保证变量的唯一 
性和准确性

13.方法

a.synchronized 

synchronized可以修饰方法，但是由于同步本身就是一种高开销的操作，因此我们应该尽可能的减少同步的内容，提高性能 
使用同步代码块，下面的方式

synchronized (this){
                    if (account.getBalance() > money) {
                        System.out.println(Thread.currentThread().getName() + "取钱" + money + "成功");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                        account.reduceBalance(money);
                        System.out.println("	" + Thread.currentThread().getName() + "成功后的余额: " + account.getBalance());
                    } else {
                        System.out.println(Thread.currentThread().getName() + "取钱失败");
                        System.out.println("	" + Thread.currentThread().getName() + "失败后的余额: " + account.getBalance());
                        break;
                    }
                }

b.volatile 

volatile关键字保证了每个线程所取得的共享资源变量的值是一样的，它的原理是被volatile修饰的变量被访问时，都会从内存中读取，而不是从缓存（寄存器）中，这样保证了每个线程访问到的变量值的一致性 
但是他不会保证操作的原子性

private volatile double balance;

c.java.util.concurrent包下的ReentrantLock类 
使用的方法

//需要声明这个锁
private Lock lock = new ReentrantLock();

// 存钱
public void addMoney(int money) {
lock.lock();//上锁
try{
count += money;
System.out.println(System.currentTimeMillis() + "存进：" + money);

}finally{
lock.unlock();//解锁
}
}

Lock与Synchronized的对比：
主要相同点：Lock能完成Synchronized所实现的所有功能。
主要不同点：Lock有比Synchronized更好的性能。Synchronized会自动释放锁，但是Lock一定要求程序员手工释放，并且必须在finally从句中释放。
synchronized 修饰方法时 表示同一个对象在不同的线程中 表现为同步队列
如果实例化不同的对象 那么synchronized就不会出现同步效果了。
d.ThreadLocal 

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。
这样的话当操作不一致的时候，就无法解决问题，会出现下面的结果

public class Bank {

private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
// TODO Auto-generated method stub
return 0;
}

};
// 存钱
public void addMoney(int money) {
count.set(count.get()+money);
System.out.println(System.currentTimeMillis() + "存进：" + money);

}

// 取钱
public void subMoney(int money) {
if (count.get() - money < 0) {
System.out.println("余额不足");
return;
}
count.set(count.get()- money);
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}

// 查询
public void lookMoney() {
System.out.println("账户余额：" + count.get());
}
}

package threadTest;


public class SyncThreadTest {

public static void main(String args[]){
final Bank bank=new Bank();

Thread tadd=new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bank.addMoney(100);
bank.lookMoney();
System.out.println("
");

}
}
});

Thread tsub = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
while(true){
bank.subMoney(100);
bank.lookMoney();
System.out.println("
");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
tsub.start();

tadd.start();
}
}

第二部分：实验部分

1、实验目的与要求

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

(2) 线程综合编程练习

2、实验内容和步骤

实验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 n 账号
    * @param initialBalance 每个账户的初始余额
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
      bankLock = new ReentrantLock();
      sufficientFunds = bankLock.newCondition();//在等待条件前，锁必须由当前线程保持。
   }
 
   /**
    * 把钱从一个账户转到另一个账户。
    * @param 从账户转账
    * @param 转到要转账的账户
    * @param 请允许我向你转达
    */
   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();//解锁。
      }
   }
 
   /**
    * 获取所有帐户余额的总和。
    * @return 总余额
    */
   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.*;

/**
 * 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();
  }
}　　

运行结果如下：

 改进后代码如下：

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：结对编程练习包含以下4部分

结对伙伴：杨丽霞

1)   程序设计思路简述；

    程序的主要设计思路没有太繁琐，只是新建三个售票口，在thread类中创建线程并开启线程，然后在run方法中定义线程任务，进行异常处理后设计在10张票数内时将售票情况进行打印，票数超过10张时程序结束；

2)   符合编程规范的程序代码；

package math;
 
public class Demo {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        Thread ticket1 = new Thread(mythread);
        Thread ticket2 = new Thread(mythread);
        Thread ticket3 = new Thread(mythread);//新建三个Thread类对象
        ticket1.start();
        ticket2.start();
        ticket3.start();//调用thread类的start方法来开启线程
    }
}
 
class Mythread implements Runnable {//实现runnable接口进行线程的创建
    int ticket = 1;
    boolean flag = true;
 
    @Override
    public void run() {//将线程任务代码定义到run方法中
        while (flag) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
 
            synchronized (this) {
                if (ticket <= 10) {
                    System.out.println(Thread.currentThread().getName() + "窗口售：第" + ticket + "张票");
                    ticket++;//票数在10张之内时，进行打印直到售出10张票时停止
                }
                if (ticket > 10) {
                    flag = false;
                }
            }
        }
    }
 
}

3)   程序运行功能界面截图；

三、实验总结：

        通过这次实验，我主要掌握了同步线程的相关问题，也学习了并发多线程，学习了锁对象、synchronized关键字等。在解读代码的过程中有好多不懂的代码，在程序测试出来后又通过对照运行结果，可以更加直观的体会有些代码的作用，加强对相关知识的理解，在平时要多加强动手能力，多思考。