java多线程编程的两种方式

上一篇文章讲了多线程的同步但是发现好多同学对多线程的如何编程有点疑惑，今天根据网上的一些资料和方法来简单根据我之前的示例代码来演示一些，多线程编程实现的两种方法：

1、定义类继承thread类并且重写其run方法，最好调用其run()方法运行。

以下是main函数中的调用运行多线程代码：（继承thread重写run来实现的）

        ThreadUseExtendsSub tsub2=new ThreadUseExtendsSub();
        ThreadUseExtendsAdd tadd2=new ThreadUseExtendsAdd();
        tadd2.run(bank);
        tsub2.run(bank);

下面是继承thread类的具体实现代码：

class ThreadUseExtendsSub extends Thread
//通过继承Thread类,并实现它的抽象方法run()
{

    public void run(Bank bank)
    {
        bank.subMoney(100);
        bank.lookMoney();
        try
        {
            sleep(1000);//挂起1秒
        }
        catch (InterruptedException e)
        {
            return;
        }
    }
}
class ThreadUseExtendsAdd extends Thread
//通过继承Thread类,并实现它的抽象方法run()
{
    public void run(Bank bank)
    {
        try
        {
            sleep(1000);//挂起1秒
        }
        catch (InterruptedException e)
        {
            return;
        }
        bank.addMoney(100);
        bank.lookMoney();
    }
}

2、定义类实现Runnable接口，覆盖Runnable接口中的run()方法，通过thread类建立线程对象，然后调用start()方法运行run

以下是调用代码：

        Thread tadd1=new Thread(new ThreadUseRunnableAdd(bank));
        Thread tsub1=new Thread(new ThreadUseRunnableSub(bank));
        tadd1.start();
        tsub1.start();

下面是实现Runnable方法的实现方式：

class ThreadUseRunnableAdd implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
{
    private Bank bank=new Bank();
    ThreadUseRunnableAdd(Bank bank1){ bank=bank1;}//构造函数
    public void run()
    {
        try
        {
            Thread.sleep(1000);//挂起5秒
        }
        catch (InterruptedException e)
        {
            return;
        }
        bank.addMoney(100);
        bank.lookMoney();
    }
}

class ThreadUseRunnableSub implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
{
    private Bank bank=new Bank();
    ThreadUseRunnableSub(Bank bank1){ bank=bank1;}//构造函数
    public void run()
    {
        bank.subMoney(100);
        bank.lookMoney();
        try
        {
            Thread.sleep(1000);//挂起5秒
        }
        catch (InterruptedException e)
        {
            return;
        }
    }
}

简单的来说，就是继承和实现接口的区别如下：

1、当使用继承的时候，主要是为了不必重新开发，并且在不必了解实现细节的情况下拥有了父类我所需要的特征。它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，
2、java只能单继承，因此如果是采用继承Thread的方法，那么在以后进行代码重构的时候可能会遇到问题，因为你无法继承别的类了，在其他的方面，两者之间并没什么太大的区别。
3、implement Runnable是面向接口，扩展性等方面比extends Thread好。
4、使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。

最后附上Bank类：

import java.text.SimpleDateFormat;
import java.util.Date;
public class Bank {
    private int count =0;//账户余额  
    //存钱  

    public  void addMoney(int money){
        synchronized(this) {count +=money;}
        System.out.println(getCurrentTime()+"存进："+money);
    }
    //取钱  
    public  void subMoney(int money){
        synchronized(this) {
            if(count-money < 0){
                System.out.println("余额不足");
                return;
            }
            count -=money;}
        System.out.println(getCurrentTime()+"取出："+money);
    }
    //查询  
    public void lookMoney(){
        System.out.println(getCurrentTime()+"账户余额："+count);
    }
    public static String getCurrentTime() {
        String returnStr = null;
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();
        returnStr = f.format(date);
        return returnStr;
    }
}  

main函数代码：

/**
 * Created by mac on 16/9/8.
 */

public class MutiThreadSyn {

    public static void main(String args[]){
        final Bank bank=new Bank();
        Thread tadd1=new Thread(new ThreadUseRunnableAdd(bank));
        Thread tsub1=new Thread(new ThreadUseRunnableSub(bank));
        tadd1.start();
        tsub1.start();
        ThreadUseExtendsSub tsub2=new ThreadUseExtendsSub();
        ThreadUseExtendsAdd tadd2=new ThreadUseExtendsAdd();
        tadd2.run(bank);
        tsub2.run(bank);

    }

}


class ThreadUseExtendsSub extends Thread
//通过继承Thread类,并实现它的抽象方法run()
{

    public void run(Bank bank)
    {
        bank.subMoney(100);
        bank.lookMoney();
        try
        {
            sleep(1000);//挂起1秒
        }
        catch (InterruptedException e)
        {
            return;
        }
    }
}
class ThreadUseExtendsAdd extends Thread
//通过继承Thread类,并实现它的抽象方法run()
{
    public void run(Bank bank)
    {
        try
        {
            sleep(1000);//挂起1秒
        }
        catch (InterruptedException e)
        {
            return;
        }
        bank.addMoney(100);
        bank.lookMoney();
    }
}

class ThreadUseRunnableAdd implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
{
    private Bank bank=new Bank();
    ThreadUseRunnableAdd(Bank bank1){ bank=bank1;}//构造函数
    public void run()
    {
        try
        {
            Thread.sleep(1000);//挂起5秒
        }
        catch (InterruptedException e)
        {
            return;
        }
        bank.addMoney(100);
        bank.lookMoney();
    }
}

class ThreadUseRunnableSub implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
{
    private Bank bank=new Bank();
    ThreadUseRunnableSub(Bank bank1){ bank=bank1;}//构造函数
    public void run()
    {
        bank.subMoney(100);
        bank.lookMoney();
        try
        {
            Thread.sleep(1000);//挂起5秒
        }
        catch (InterruptedException e)
        {
            return;
        }
    }
}