浅谈java的多线程

在java中有三种多线程方法

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口

1.集成Thread类

package Head;
import java.lang.Thread;

class MyThread extends Thread{
    private String name;
    private int num;
    public MyThread(String name,int num) {
        this.name = name;
        this.num = num;
    }
    @Override
    public void run() {
        for(int i=num;i>=0;i--) {
            System.out.println(this.name+"还有"+i+"次机会");
        }
    }
}

public class Exp91 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread mt1 = new MyThread("线程A",4);
        MyThread mt2 = new MyThread("线程B",5);
        MyThread mt3 = new MyThread("线程C",2);

        mt1.start();
        mt2.start();
        mt3.start();
    }

}

//继承Thread类的结果
线程A还有4次机会
线程C还有2次机会
线程C还有1次机会
线程C还有0次机会
线程B还有5次机会
线程A还有3次机会
线程B还有4次机会
线程A还有2次机会
线程B还有3次机会
线程A还有1次机会
线程A还有0次机会
线程B还有2次机会
线程B还有1次机会
线程B还有0次机会

2.实现Runnable接口

package Head;

import java.lang.Thread;

class MyThread4 implements Runnable{
    private int ticket = 5;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i=0;i<50;i++) {
            if(this.ticket>0) {
                System.out.println("售票：ticket="+this.ticket--);
            }
        }
    }
}

public class Exp98 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread4 ab = new MyThread4 ();
        new Thread(ab).start();
        new Thread(ab).start();
        new Thread(ab).start();

    }

}

//实现Runnable接口
售票：ticket=4
售票：ticket=3
售票：ticket=1
售票：ticket=5
售票：ticket=2

3.实现Callbale接口

package Head;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyThread3 implements Callable<String>{
    private int ticket =10;
    @Override 
    public String call() throws Exception{
        for (int i=0;i<100;i++) {
            if(this.ticket>0) {
                System.out.println("卖票，ticket="+this.ticket--);
            }
        }
        return "票已经卖光";
    }
}

public class Exp910 {

    public static void main(String[] args)throws Exception {
        // TODO Auto-generated method stub
        MyThread3 mt1 = new MyThread3();
        MyThread3 mt2 = new MyThread3();
        FutureTask<String> task1 = new FutureTask<String>(mt1);
        FutureTask<String> task2 = new FutureTask<String>(mt2);

        new Thread(task1).start();
        new Thread(task2).start();

        System.out.println("A线程的返回结果："+task1.get());
        System.out.println("B线程的返回结果："+task2.get());

    }

}

实现Callable接口
卖票，ticket=10
卖票，ticket=10
卖票，ticket=9
卖票，ticket=8
卖票，ticket=7
卖票，ticket=6
卖票，ticket=5
卖票，ticket=4
卖票，ticket=3
卖票，ticket=2
卖票，ticket=1
卖票，ticket=9
卖票，ticket=8
卖票，ticket=7
卖票，ticket=6
卖票，ticket=5
A线程的返回结果：票已经卖光
卖票，ticket=4
卖票，ticket=3
卖票，ticket=2
卖票，ticket=1
B线程的返回结果：票已经卖光

1.在java的多线程中，我们发现Runbale能比Thread更好的方便实现数据共享的贡献，并且使用Runable接口可以避免单继承局限。

2.在使用Runable接口实现的多线程会存在一个问题那就是run()方法不能返回操作结果。

3.在实现Runable接口的时候我们需要注意我们在实例化线程对象的时候，我们实现的是new Thread(MyThread).start();

4.在实现Callable接口时候我们需要注意返回的数据类型Exp: class MyThread implements Callable，由此我们想到了泛型也是如此。

5.在Callable实现之后，我们使用的是.get()方法实现多线程执行完取得内容