线程的补充(续)

一丶强制终止一个线程的执行？

见Test01，Stop方法不建议使用，易丢失数据。

public class Test01 {

//强制终止线程的进程测试
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.setName("t");
        t.start();
        try {
            Thread.sleep(1000 * 2);
        } catch (InterruptedException e) {
             e.printStackTrace();
        }
        //强行终止T线程
        //t.stop();//已经过时不建议使用
        //stop容易损失数据。
        //直接将进程杀死，线程未保存的数据将丢失不建议使用。
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 10;i++){
            System.out.println(Thread.currentThread().getName() + "-----" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-----end");
        }
    }
}

二丶合理的终止一个线程的执行？

见Test02，使用标记来控制线程的执行。例 boolean run = false;

public class Test02 {
    //怎么合理的终止一个线程的执行
    public static void main(String[] args) {
        MyThread02 t2 = new MyThread02();
        Thread t = new Thread(t2);
        t.setName("t");
        t.start();
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.run = false;//标记一个判断条件，后面可以控制语句的进行
    }
}
class MyThread02 implements Runnable{
    boolean run = true;
    public void run(){
        for (int i = 0; i <= 10; i++) {
            if(run) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + "-----" + i);
            }
        }
        System.out.println(Thread.currentThread().getName() + "---------" + "end");
    }
}

三丶(了解)线程调度概述？

3.1.抢占式调度模型

3.2.均分式调度模型

四丶(了解)线程的调度方法？

void setPriority() 设置线程优先级

static void yield() 暂停当前执行的线程，运行其他线程，让位。

int getPriority() 获取当前线程的优先级

优先级较高的获取cpu时间片可能会多，只是大概率并不是完全。

void join() 合并线程，当前线程进入阻塞

五丶(了解)线程的优先级？

抢到的cpu时间片不是谁先谁后，而是优先级越高处于运行时间的状态多一些。

六丶线程的让位？

Thread.yield();静态方法，其作用会让给主线程运行

七丶线程合并？

实例方法join();需要进行级try catch的异常处理，当前线程与其他线程进行协调合并。

八丶线程的安全是重点？为什么这个是重点？

以后项目都是运行在服务器中，线程对象的创建运行都不需要我们进行编写。在多线程并发的环境下是否安全。

九丶线程不安全的条件？

一是多线程并发；二是有共享数据；三是共享数据有修改的行为

十丶怎么解决线程安全问题呢？

线程排队执行来这解决线程安全问题(不能并发)，此机制被称为线程同步机制，用来解决线程安全问题。线程同步就是线程排队，会牺牲

一定效率，数据安全第一位，效率第二位，一切以安全为主。

十一丶同步和异步的理解？

异步(并发)编程模型：线程t1和t2各自执行各自的，互不相管，谁也不需要等谁，异步编程模型，多线程并发，效率较高

同步(排队)编程模型：线程t1和线程t2，在线程t1执行时必须等待t2结束，两个线程之间发生了等到关系，这就是同步编程模型，效率较低

，线程排队执行。异步就是并发，同步就是排序。

十二丶账户类的定义？

编写程序模拟两个线程同时对同一个账户进行取款操作。见test06。

十三丶模拟两个线程对同一个账户取款。

import sun.java2d.pipe.AAShapePipe;
//假设同学A和同学B同时对中国银行进行取款操作
public class Test06{
    public static void main(String[] args){
        Account account = new Account("中国银行",100000);//银行账户
        Thread t1 = new Thread(new AccountThread(account));//指向同一个账户
        Thread t2 = new Thread(new AccountThread(account));//指向同一个账户
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}
//两个线程必须共享同一个账户对象
class AccountThread implements Runnable {
    //一个账户
    private Account act;
    public AccountThread(Account act){
        this.act = act;
    }
    //run方法的执行表示取款操作
    public void run(){
        double money = 50000;//假设是需要取款这么多钱
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName()+ "取款" + money +"成功，余额为："+ act.getBalance());
    }
}
class Account{
    private String actno;//账户
    private double balance;//余额
    public Account(){//构造器
    }
    public Account(String actno,double balance){//有参构造器
        this.actno = actno;
        this.balance = balance;
    }
    public String getActno() {
        return actno;
    }
    public void setActno(String actno) {
        this.actno = actno;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取款方法
    public void withdraw(double money){
        double before = this.getBalance();//取款之前的余额
        double after = before - money;//取款后的余额
        this.setBalance(after);
    }
}