3.30学习进度

技术学习

Java

HF Java

进程 Thread

• 启动新的线程步骤

  1. 建立Runable对象(线程的任务)
     Runnable threadJob = new MyRunnable();

  2. 建立Trhead对象(执行工人)并赋值Runnable(任务)
     Thread myThread = new Thread(threadJob)

  3. 启动Thread
     myThread.start();

测试示例

//实现Runnable接口来建立给thread运行的任务
public class MyRunnable implements Runnable {
    @Override
    public void run() {
    //Runnable是抽象类,所以一定要实现其中所有的方法
    //没有参数,要运行的程序代码放在这里
        doIt();
    }
    public void doIt() {
        System.out.println("you r in a thread");
    }
}

//线程测试启动器
public class ThreadTestDrive {
    public static void main(String[] args) {
        Runnable threadJob = new MyRunnable();
        Thread myTread = new Thread(threadJob);
        myTread.start();
        System.out.println("now you r in main");
    }
}

输出结果（可能是）：

now you r in main
you r in a thread

• 对输出结果进行分析,发现从逻辑上不符合设计时候的输出结果,因此对线程运行的时候进行分析。
  
  • 运行的时候,main（）启动的主线程,和自定义的新建线程会交替运行,意思是有时候会先运行一下主线程,然后执行一下新的线程的建立就回到主线程,这样子就会造成主线程执行到输出语句后,才转到新建线程执行输出语句。

线程thread的一些基本概念

 1. 以小写t描述的thread是一个独立的线程
 2. Java中每一个线程都有独立的执行空间
 3. 大写Thread是java。lang。Thread这个类,它的对象用于表示线程
 4. Thread需要任务,通过Runnable的实例
 5. 需要将Runnable传给Thread的构造函数才能启动新的线程 
 6. Java虚拟机的调度器不能保证人和线程的执行时间和顺序,所以期待它会完全地保证平均分配执行。

对使用线程的一些小改进---使用sleep()

• 注意,sleep可能会抛出异常,因此对它的调用必须包在try-catch中

改进后的测试示例

//(改进后的)实现Runnable接口来建立给thread运行的任务
public class MyRunnable implements Runnable {
    @Override
    public void run() {
    //Runnable是抽象类,所以一定要实现其中所有的方法
    //没有参数,要运行的程序代码放在这里
    /*
     * 改进的代码
     */
    try{
        Thread.sleep(2000);  //强迫进程离开执行中的状态
    }catch(InterruptedException ex) {
        ex.printStackTrace();
    }   
    /*
     * 以下为执行代码
     */
    doIt();
    }
    public void doIt() {
        System.out.println("you r in a thread");
    }
}

//线程测试启动器
public class ThreadTestDrive {
    public static void main(String[] args) {
        Runnable threadJob = new MyRunnable();
        Thread myTread = new Thread(threadJob);
        myTread.start();
        System.out.println("now you r in main");
    }
}

输出结果（一定是）：

now you r in main
you r in a thread

建立和启动两个线程示例

//测试 启动和建立两个线程
public class ThreadTestDrive implements Runnable {
    public static void main(String[] args) {
        //创建出ThreaTestDrive实例
        ThreadTestDrive runner = new ThreadTestDrive();
        //创建出两个Thread实例     
        Thread alpha = new Thread(runner); 
        Thread beta =  new Thread(runner);
        //分别对两个线程进行名字修改
        alpha.setName("Thread Alpha");
        beta.setName("Thread Beta");
        //启动两个线程
        alpha.start();
        beta.start();
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i ++) {              
        //每一个线程运行个五次,显示出当前运行的是哪一个线程
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "正在执行");
        }
    }
}

测试结果：

Thread Alpha正在执行
Thread Beta正在执行
Thread Beta正在执行
Thread Beta正在执行
Thread Beta正在执行
Thread Beta正在执行
Thread Alpha正在执行
Thread Alpha正在执行
Thread Alpha正在执行
Thread Alpha正在执行

• 可以看出,Alpha线程运行了一次之后,调度器就开始调到Beta线程开始运行,并且将Beta线程运行了五次,所以更加验证了那一句话,线程的运行取决于调度

线程的并发性问题

• 一言不合就用代码来说明有多严重

//两人的银行账号类
public class BankAccount {
    private int balance = 3000;    //将存款数设为私有,以保护
    public int getBalance() {      //声明一个公共的方法让两人查询账户存款
        return balance;
    }
    public void withdraw (int amount){ //取出存款的方法
        balance = balance - amount;
    }
}

//创建两个线程并对银行账户进行取款或者查看的任务
public class MoneyRunnable implements Runnable {
    private BankAccount account = new BankAccount();
    public static void main(String[] args) {
        //将MoneyRunnable实例化
        MoneyRunnable job = new MoneyRunnable();
        //创建两个线程并对它们分别命名后启动
        Thread boy = new Thread(job);
        Thread girl = new Thread(job);
        boy.setName("BoyFriend");
        girl.setName("GirlFriend");
        boy.start();
        girl.start();
    }
    //重写Runnable下的run()方法
    @Override
    public void run() {
       for(int x = 0;x <10; x++) {
           makeWithdrawal(300);     //一次取款300
           if(account.getBalance() < 0) {
               System.out.println("超出预支了！");
           }
       }
    }
    //定义一个取款的方法让两人取款
    private void makeWithdrawal(int amount) {
        if(account.getBalance() >= amount) {
            System.out.println(Thread.currentThread().getName()+ "准备取款");
            try{
                System.out.println(Thread.currentThread().getName() + "准备进入不执行状态");
                Thread.sleep(500);       //让boy线程睡眠
            } catch(InterruptedException ex) {
                ex.printStackTrace();
            }
        System.out.println(Thread.currentThread().getName() + "进入活动状态");
        account.withdraw(amount);
        System.out.println(Thread.currentThread().getName() + "完成取款");
        }
        else {
            System.out.println("对不起," + Thread.currentThread().getName() + ",没钱了,取不到钱");
        }
    }
}

输出结果:

GirlFriend准备取款
BoyFriend准备取款
GirlFriend准备进入不执行状态
BoyFriend准备进入不执行状态
BoyFriend进入活动状态
BoyFriend完成取款
BoyFriend准备取款
BoyFriend准备进入不执行状态
GirlFriend进入活动状态
GirlFriend完成取款
GirlFriend准备取款
GirlFriend准备进入不执行状态
BoyFriend进入活动状态
BoyFriend完成取款
BoyFriend准备取款
BoyFriend准备进入不执行状态
GirlFriend进入活动状态
GirlFriend完成取款
GirlFriend准备取款
GirlFriend准备进入不执行状态
GirlFriend进入活动状态
GirlFriend完成取款
对不起,GirlFriend,没钱了,取不到钱
BoyFriend进入活动状态
BoyFriend完成取款
超出预支了！
对不起,BoyFriend,没钱了,取不到钱
超出预支了！
对不起,BoyFriend,没钱了,取不到钱
超出预支了！
对不起,GirlFriend,没钱了,取不到钱
超出预支了！

• 这个输出结果有一点长,我们进行分析可以知道,boy线程和girl线程都会在取款之前读取存款余额,本来是不可能会出现有说不够钱的这个问题出现的,但是注意到我们在线程读取完额度之后让其进入不活跃状态,此时取出存款的开口对于其他线程是打开的,其他线程不会因为其他线程占用了此开口就不接入此口,因此我们需要将取出存款加一个机制验证是否有线程在使用
• 为达到上述目的,我们可以使用synchronized修饰,使这个方法变成一个同步化的方法。

修改后,运行结果中不会出现“超出预支”这个情况了.

• 但是同步化不是万能的,同步化会造成性能损耗,并且有可能造成死锁,因此,对于需要同步化的方法我们可以选择参数索指定的对象的锁来做同步化.
• 对象就算有多个同步化的方法也还是只有一个锁,一单一个线程进入对象的其中一个同步化方法,其他的线程就无法进入该对象.