java基础之线程

文章标题

    • 线程的生命周期
    • join线程
    • 线程同步
    • 同步代码块
    • 同步方法
    • 同步锁
    • 死锁
    • 线程通信

线程的生命周期

java基础之线程_第1张图片

package xiancheng;

public class InvokeRun extends Thread{
    private int i;
    //重写run()方法,run()方法的方法体就是线程执行体

    @Override
    public void run() {
        for (;i<100;i++){
            //直接调用run()方法时,Thread的this.getName()返回的时该对象的名字
            //而不是当前线程的名字
            //使用Thread.currentTread().getName()总是获取当前线程的名字
            System.out.println(Thread.currentThread().getName()+""+i);
        }
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==20){
                //直接调用线程对象的run()方法
                //系统会把线程对象当成普通对象,把run()方法当成普通方法
                //所以下面两行代码并不会启动两个线程,而是依次执行两个run()方法
                new InvokeRun().run();
                new InvokeRun().run();
            }
        }
    }
}

java基础之线程_第2张图片

程序运行的结果是整个程序只有一个线程:主线程。还有一点如果直接调用线程对象的run()方法,则run()方法里不能直接通过getName()方法来获得当前线程的名字,而是需要使用Thread.currentThread()方法获取当前线程,再调用线程对象的getName()方法来获得线程的名字。
启动线程的正确方法是调用Thread对象的start()方法,而不是直接调用run()方法,否则就变成单线程程序了。

package xiancheng;

public class InvokeRun extends Thread{
    private int i;
    //重写run()方法,run()方法的方法体就是线程执行体
    @Override
    public void run() {
        for (;i<100;i++){
            System.out.println(getName()+""+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        InvokeRun sd= new InvokeRun();
        for(int i=0;i<300;i++){
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==20){
                //启动线程
                sd.start();
                //判断启动后线程的isAlive()的值,输出true
                System.out.println(sd.isAlive());
            }
            //当线程处于新建,死亡两种状态时,isAlive()方法返回false
            //当i>20时,该线程肯定已经启动过了,如果sd.isAlive()为假时
            //那就是死亡状态
            if(i>20&&!sd.isAlive()){
                //试图再次启动该线程
                sd.start();
            }
        }
    }
}

java基础之线程_第3张图片
上面的程序为线程死亡,线程死亡的情况下不能调用start方法启动线程,因为i>20,线程已经启动过了,也就是运行后过一段时间就会进入死亡状态。

join线程

Thread提供了让一个线程等待另一个线程完成的方法–join()方法。当某个程序执行流中调用其他线程的join()方法时,调用程序将被阻塞,直到被join()方法加入的join线程执行完为止。

package xiancheng;

public class JoinThread  extends Thread{
    //提供一个有参数的构造器,用于设置该线程的名字
    public JoinThread(String name){
        super(name);
    }
    //重写run()方法,定义线程执行体
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(getName()+" "+i);
        }
    }

    public static void main(String[] args) throws Exception{
        //启动子线程
        new JoinThread("新线程").start();
        for(int i=0;i<100;i++){
            if(i==20){
                JoinThread jt = new JoinThread("被join的线程");
                jt.start();
                //main线程调用了jt线程的join()方法,main线程
                //必须等jt执行结束才会向下执行
                jt.join();
            }
            System.out.println(Thread.currentThread().getName()+"主线程 "+i);
        }
    }
}

java基础之线程_第4张图片
上面程序一共有三个线程,主方法开始时就启动了名为“新线程”的子线程,该子线程将会和main线程并发执行。当主线程的循环变量i等于20时,启动了名为“被Join的线程”的线程,该线程不会和main线程并发执行,main线程必须等该线程执行结束后才可以向下执行。在名为“被join的线程”的线程执行时,实际上只有两个子线程并发执行,而主线程处于等待状态。
因为主线程执行到join,所以就要等待被join的那个线程。在java里,main方法里就是主线程。Android的话一般自己不new一个新线程的话基本上都是主线程。

线程同步

线程安全问题:银行取钱例子
账户类

package xiancheng;

public class Account {
    //封装账号编号,账户余额的两个成员变量
    private String accountNo;
    private double balance;
    public Account(){

    }
    //构造器
    public Account(String accountNo,double balance){
        this.accountNo=accountNo;
        this.balance=balance;
    }

    @Override
    public int hashCode() {
        return accountNo.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj) {
            return true;
        }
            if(obj!=null&&obj.getClass()==Account.class){
                Account target = (Account) obj;
                return target.getAccountNo().equals(accountNo);
            }

        return false;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

取钱的线程类

package xiancheng;

public class DrawThread extends Thread{
    //模拟用户账户
    private Account account;
    //当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name,Account account,double drawAmount){
        super(name);
        this.account=account;
        this.drawAmount=drawAmount;
    }
    //当多个线程修改同一个共享数据时,将涉及数据安全问题
    public void run(){
        //账户余额大于取钱数目
        if(account.getBalance()>=drawAmount){
            //吐出钞票
            System.out.println(getName()+"取钱成功!吐出钞票:"+drawAmount);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改余额
            account.setBalance(account.getBalance()-drawAmount);
            System.out.println("\t余额为:"+account.getBalance());
        }else {
            System.out.println(getName()+"取钱失败!余额不足!");
        }

    }
}

测试类

package xiancheng;

public class DrawTest {
    public static void main(String[] args) {
        //创建一个账户
        Account account = new Account("1234567", 1000);
        //模拟两个线程对同一个账户取钱
        new DrawThread("甲",account,800).start();
        new DrawThread("乙",account,800).start();
    }
}

java基础之线程_第5张图片
问题出现了,余额出现负数,这不是银行希望出现的结果,程序中有两个并发线程在修改Account对象,而且系统在睡眠1s的时候切换到另一个线程去修改。这样不具有同步安全性。

同步代码块

package xiancheng;

public class DrawThread extends Thread{
    //模拟用户账户
    private Account account;
    //当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name,Account account,double drawAmount){
        super(name);
        this.account=account;
        this.drawAmount=drawAmount;
    }
    //当多个线程修改同一个共享数据时,将涉及数据安全问题
    public void run(){
        //使用account作为同步监视器,任何线程进入下面同步代码块之前
        //必须先获得对account账户的锁定--其他线程无法获得锁,也就无法修改它
        //这种做法符合:“加锁-修改-释放锁”的逻辑
        synchronized (account) {
            //账户余额大于取钱数目
            if (account.getBalance() >= drawAmount) {
                //吐出钞票
                System.out.println(getName() + "取钱成功!吐出钞票:" + drawAmount);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改余额
                account.setBalance(account.getBalance() - drawAmount);
                System.out.println("\t余额为:" + account.getBalance());
            } else {
                System.out.println(getName() + "取钱失败!余额不足!");
            }
        }
        //同步代码块结束,该线程释放同步锁
    }
}

java基础之线程_第6张图片
为了解决这个问题,java多线程引入同步监听器,使用同步监听器的通用方法就是同步代码块。同步代码块的语法格式如下:

synchronized(obj){
...
//此处的代码就是同步代码块
}

上面语法格式中,synchronized后的括号里的obj就是同步监听器,上面代码的含义是:线程开始执行同步代码块之前,必须先获得对同步监听器的锁定。
虽然java程序允许使用任何对象作为同步监听器,但想一下同步监听器的目的:阻止两个线程对同一个共享资源进行并发访问,因此通常推荐使用可能被并发访问的共享资源充当同步监听器。对于上面的取钱程序,考虑是用账户(Account)作为同步监听器。

同步方法

对于synchronized修饰的实例方法,无需显示指定同步监听器,同步方法的同步监听器是this,也就是调用该方法的对象。
根据之前的取钱程序修改一下

package xiancheng;

public class Account {
    //封装账号编号,账户余额的两个成员变量
    private String accountNo;
    private double balance;
    public Account(){

    }
    //构造器
    public Account(String accountNo,double balance){
        this.accountNo=accountNo;
        this.balance=balance;
    }

    public synchronized void draw(double drawAmount){
        //账户余额大于取钱数目
        if (balance >= drawAmount) {
            //吐出钞票
            System.out.println(Thread.currentThread().getName()  + "取钱成功!吐出钞票:" + drawAmount);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //修改余额
            balance -= drawAmount;
            System.out.println("\t余额为:" + balance);
        } else {
           // System.out.println(getName() + "取钱失败!余额不足!");
            //该方法不是run方法,所以程序不认识getName()只能使用Thread.currentThread().getName()
            System.out.println(Thread.currentThread().getName() + "取钱失败!余额不足!");
        }
        }

    @Override
    public int hashCode() {
        return accountNo.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj) {
            return true;
        }
            if(obj!=null&&obj.getClass()==Account.class){
                Account target = (Account) obj;
                return target.getAccountNo().equals(accountNo);
            }

        return false;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

package xiancheng;

public class DrawThread extends Thread{
    //模拟用户账户
    private Account account;
    //当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name,Account account,double drawAmount){
        super(name);
        this.account=account;
        this.drawAmount=drawAmount;
    }
    //当多个线程修改同一个共享数据时,将涉及数据安全问题
    public void run(){
        //直接调用account对象的draw()方法来执行取钱操作
        //同步方法的同步监听器是this,this代表调用draw()方法的对象
        //也就是说,线程进入draw()方法之前,必须先对account对象加锁
        account.draw(drawAmount);
    }
}

上面程序增加了一个代表取钱的draw()方法,并使用synchronized关键字修饰该方法,把该方法变成同步方法,该同步方法的同步监听器是this,因此对于同一个Account账户而言,任何时刻只能有一个线程获得Account对象的锁定,然后进入draw()方法执行取钱操作–这样也可以保证多个线程并发取钱的线程安全。
由于已经使用synchronized关键字修饰了draw()方法,同步方法的同步监听器是this,而this总代表调用该方法的对象–在上面示例中,调用draw()方法的对象是account,因此多个线程并发修改一份account之前,必须先对account对象加锁。这也符合"加锁-修改-释放锁“的逻辑。

同步锁

在实现线程安全的控制中,比较常用的是ReentrantLock(可重入锁)。使用该lock对象可以显示地加锁,释放锁,通常使用ReentranLock的代码格式如下:

class X{

//定义锁对象
ReentranLock lock=new ReentrantLock();
//...
//定义需要保证线程安全
public void m(){
//加锁
lock.lock();
try
{
//需要保证线程安全的代码
//...method body
}
//使用finally块来保证释放锁
{
lock.unlock();}

}
package xiancheng;

import java.util.concurrent.locks.ReentrantLock;

public class Account {
    //定义锁对象
    private final ReentrantLock lock=new ReentrantLock();
    //封装账号编号,账户余额的两个成员变量
    private String accountNo;
    private double balance;
    public Account(){

    }
    //构造器
    public Account(String accountNo,double balance){
        this.accountNo=accountNo;
        this.balance=balance;
    }

    public void draw(double drawAmount) {
        //加锁
        lock.lock();
        try {
            //账户余额大于取钱数目
            if (balance >= drawAmount) {
                //吐出钞票
                System.out.println(Thread.currentThread().getName() + "取钱成功!吐出钞票:" + drawAmount);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改余额
                balance -= drawAmount;
                System.out.println("\t余额为:" + balance);
            } else {
                // System.out.println(getName() + "取钱失败!余额不足!");
                //该方法不是run方法,所以程序不认识getName()只能使用Thread.currentThread().getName()
                System.out.println(Thread.currentThread().getName() + "取钱失败!余额不足!");
            }
        }
        finally {
            //修改完成,释放锁
            lock.unlock();
        }
    }

    @Override
    public int hashCode() {
        return accountNo.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj) {
            return true;
        }
            if(obj!=null&&obj.getClass()==Account.class){
                Account target = (Account) obj;
                return target.getAccountNo().equals(accountNo);
            }

        return false;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

上面程序定义了一个ReentrantLock对象,程序中实现draw()方法时,进入方法开始执行后立即请求对ReentrantLock对象进行加锁,当执行完draw()后的取钱逻辑后,程序使用finally块来确保释放锁。

死锁

当两个线程相互等待对方释放同步监听器时就会发生死锁

package xiancheng;
class A{
    public synchronized void foo(B b){
        System.out.println("当前线程名:"+Thread.currentThread().getName()+"进入了A实例的foo()方法");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println("当前线程名:"+Thread.currentThread().getName()+"企图调用B实例的last()方法");//3号
            b.last();
    }
    public synchronized void last(){
        System.out.println("进入了A类的last()方法");
    }
}
class B{
    public synchronized void bar(A a){
        System.out.println("当前线程名:"+Thread.currentThread().getName()+"进入了B实例的bar()方法");
        try {
            Thread.sleep(200);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        System.out.println("当前线程名:"+Thread.currentThread().getName()+"企图调用A实例的last()方法");//4号
        a.last();
    }
    public synchronized void last(){
        System.out.println("进入了B类的last()方法内部");
    }

}

public class DeadLock implements Runnable{
    A a=new A();
    B b=new B();


    @Override
    public void run() {
     Thread.currentThread().setName("副线程");
     //调用b对象的bar()方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }
    public void init() {

        Thread.currentThread().setName("主线程");
        //调用a对象的foo()方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }

    public static void main(String[] args) {
        DeadLock d1 = new DeadLock();
        //以d1为target启动新线程
        new Thread(d1).start();
        //调用init()方法
        d1.init();
    }
}

java基础之线程_第7张图片
主要发生在last()方法,直到3号代码处希望调用B对象的last()方法–执行该方法之前必须先对B对象加锁,但此时副线程正保持着B对象的锁,所以主线程阻塞;接下来副线程应该也醒过来继续向下执行,直到4号代码处希望调用A对象的last()方法–执行该方法之前必须先对A对象加锁,但此时主线程没有释放A对象的锁–但此时主线程没有释放A对象的锁–至此,就出现了主线程保持着A对象的锁,等待B对象加锁,而副线程保持着B对象的锁,等待对A对象加锁,两个线程互相等待

线程通信

假设现在系统中有两个线程,这两个线程分别代表存款者和取钱着–现在假设有一种特殊的要求,系统要求存款者和取钱者不断重复存款,取钱的动作,而且要求每当存款者将钱存入指定账户后,取钱者就立即取出该笔钱。不允许存款者连续两次存钱,也不允许取钱者两次取钱。
为了实现这种功能,可以借助Object类提供的wait(),notify()和notifyAll()三个方法,这三个方法不属于Thread类,属于Object类。但这三个方法必须由同步监听器对象来调用。
对于使用synchronized修饰的同步方法,因为本身所在类的默认实例(this)就是同步监听器,所以可以直接在同步方法中调用这三个方法。
对于使用synchronized修饰的同步代码块,同步监听器是synchronized后括号里的对象,所以必须使用该对象调用
wait():导致当前线程等待,直到有notify方法或notifyAll()方法来唤醒该线程。调用wait方法的当前线程会释放对该同步监听器的锁定。
notify():唤醒此同步监听器上等待的单个线程。只有当前线程释放对该同步监听器的锁定,才可以执行被唤醒的线程,也就是执行到wait方法
notifyAll():唤醒在此同步监听器上等待所有的线程。只有当前线程释放对该同步监听器的锁定,才可以执行被唤醒的线程,也就是执行到wait方法

package xiancheng;


public class Account {

    private String accountNo;
    private double balance;
    //标识账户中是否已有存款的旗标
    private boolean flag=false;
    public Account(){

    }
    //构造器
    public Account(String accountNo,double balance){
        this.accountNo=accountNo;
        this.balance=balance;
    }

    //因为账户余额不允许随便修改,所以只为balance提供getter方法
    public double getBalance(){
        return this.balance;
    }
    public synchronized void draw(double drawAmount) {
        try {
            //如果flag为假,表明账户中还没有人存钱进去,取钱方法阻塞
            if(!flag){
                wait();
            }
            else {
                //执行取钱操作
                System.out.println(Thread.currentThread().getName() + "取钱" + drawAmount);
                balance -= drawAmount;
                System.out.println("账户余额为:" + balance);
                //将标识账户是否已有存款的旗帜设为false
                flag=false;
                //唤醒其他线程
                notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void deposit(double depositAmount){
        try {
            //如果flag为真,表明账户中已有人存钱进去,存钱方法阻塞
            if(flag){
                wait();
            }else {
                //执行存款操作
                System.out.println(Thread.currentThread().getName() + "存款" + depositAmount);
                balance+=depositAmount;
                System.out.println("账户余额为:"+balance);
                //将表示账户是否已有存款的旗标设为true
                flag=true;
                //唤醒其他线程
                notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public int hashCode() {
        return accountNo.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj) {
            return true;
        }
            if(obj!=null&&obj.getClass()==Account.class){
                Account target = (Account) obj;
                return target.getAccountNo().equals(accountNo);
            }

        return false;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }



    public void setBalance(double balance) {
        this.balance = balance;
    }
}

package xiancheng;

public class DrawThread extends Thread{
    //模拟用户账户
    private Account account;
    //当前取钱线程所希望取的钱数
    private double drawAmount;
    public DrawThread(String name,Account account,double drawAmount){
        super(name);
        this.account=account;
        this.drawAmount=drawAmount;
    }
    //重复100次执行取钱操作
    @Override
    public void run() {
       for(int i=0;i<2;i++){
           account.draw(drawAmount);
       }
    }
}

package xiancheng;

public class DepositThread extends Thread{
    //模拟用户账户
    private Account account;
    //当前存款线程所希望存的钱数
    private double depositAmount;
    public DepositThread(String name,Account account,double depositAmount){
        super(name);
        this.account=account;
        this.depositAmount=depositAmount;
    }
    //重复100次执行存款操作

    @Override
    public void run() {
        for(int i=0;i<2;i++){
            account.deposit(depositAmount);
        }
    }
}

package xiancheng;

public class DrawTest {
    public static void main(String[] args) {
        //创建一个账户
        Account acc = new Account("1234567", 0);
        //取钱线程
        new DrawThread("取钱者",acc,800).start();
        //存钱线程
        new DepositThread("存款者甲",acc,800).start();
        new DepositThread("存款者乙",acc,800).start();
        new DepositThread("存款者丙",acc,800).start();

    }
}

java基础之线程_第8张图片
因为在上面程序中,同步监听器对象都是account(因为调用同步方法中的this是调用方法的对象,都是account)。所以在notifyAll时不仅会唤醒所在同步方法里的线程,也会唤醒另一个同步方法的线程。

package xiancheng;

public class TestMain {
    //对象锁一
    private static Object lock1 = new Object();
    //对象锁二
    private static Object lock2 = new Object();

    public static void main(String[] args) throws Exception {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println("线程一拿到了lock1锁");
                    System.out.println("线程一准备获取lock2锁");
                    synchronized (lock2) {
                        System.out.println("线程一拿到了lock2锁");
                        try {
                            System.out.println("线程一释放了lock1锁");
                            //先让出lock1锁,不设置超时时间
                            lock1.wait();
                            //唤醒lock1等待的线程
                            lock1.notify();
                            System.out.println("线程一运行结束");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //睡眠一秒,让线程一能够成功运行到wait()方法,释放lock1锁
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程二拿到了lock1锁,开始运行");
                    System.out.println("线程二准备获取lock2锁");
                    //唤醒lock1等待的线程
                    lock1.notify();
                    try {
                        //先让出lock1锁,不设置超时时间
                        lock1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        System.out.println("线程二拿到了lock2锁,开始运行");
                        System.out.println("线程二运行结束");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
    }

}

java基础之线程_第9张图片
可以看到,线程一和线程二都能够顺利执行结束了。其实本质上就是让他们互相协作,完成工作。wait方法只会释放当前对象的锁,不会释放所有锁。thread2中有句"线程二准备获取lock2锁",但这时候lock2锁是被线程一持有着的,而线程一其实只让出了lock1锁,同时处于wait状态而不是等待着锁的阻塞,所以这时候需要线程二lock1.notify()方法,把线程一唤醒,让它继续执行,只有线程一继续执行结束后,线程二才能拿到lock2锁,才能进入lock2同步代码块执行(在同步方法synchronized执行结束后,也就会自动释放锁)。
还要需要注意的一点是,wait方法释放锁后,只有在等待锁处于阻塞状态的线程可以继续执行(也就是想要进入synchronized的线程),而那些处于wait状态的线程,是需要被唤醒,才能继续执行的,这也是为什么线程二要调用notify方法的原因了。

当你在所在的Activity开启了一个后台线程,线程在执行过程中要遇到死亡或阻塞条件才结束,所以当你Activity销毁后,但是线程还存活的话会执行直到死亡

你可能感兴趣的:(Java,java,jvm,开发语言)