滴答Java多线程01

多线程的目的归根结底是为了高效，重叠执行一些独立的代码（图形化应用程序等）。

输入输出数据的时间因为非常短（相对于处理数据），所以在处理数据的同时读取数据不是更加节约时间么。

把单个程序化为多线程的关键是两个线程不能同时执行，在存取数据之前要确保数据块已清空，在写入之前应该确保计算已经结束。这就需要线程之间可以互相通信。

t01

package prac01;
class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    public void run(){
        for(int i = 0;i<10;i++){
            System.out.println(name+"运行，i="+i);
        }
    }
}//MyThread
public class Prac01{
    public static void main(String[] args){
        MyThread t1 = new MyThread("Thread A ");
        MyThread t2 = new MyThread("Thread B");
        t1.start();
        t2.start();
        //不能直接调用run，应该使用start，多线程需要本机操作系统支持
        //start执行中调用start0方法，start0方法为private native void start0
        //native表示调用本机操作系统函数，一次start只能调用一次，二次调用会抛出illegalthreadstateexception
    }
}

t02

package prac01;

class MyThread implements Runnable{
    private String name;
    public MyThread(String name){
        this.name = name;
    }//constructor
    public void run(){
        for(int i = 0;i<10;i++){
            System.out.println(name+"运行，i="+i);
        }//for
    }//run
}//MyThread
public class Prac01{
    public static void main(String[] args){
        MyThread mt1 = new MyThread("线程A");
        MyThread mt2 = new MyThread("线程B");
        Thread th1 = new Thread(mt1);
        Thread th2 = new Thread(mt2);
        th1.start();
        th2.start();
    }//main
    //就算是Runnable接口，执行线程任务也要Thread来帮助
    //有个Thread的构造方法，其参数就是Runnable对象。
    //就是说创建个Thread对象，并用一个Runnable对象传入Thread构造方法进行初始化
    //即可正常使用多线程，且可以多继承
}//Prac01

t03

package prac01;
//同样是卖5张票，比较下用Thread和Runnable的区别
class MyThread extends Thread{
    private int ticket = 5;
    private String name;
    public MyThread(String name){
        this.name = name;
    }//constructor
    public void run(){
        for(int i=0;i<100;i++){
            if(ticket > 0){
                System.out.println("线程卖票后"+name+"还剩几张票-"+ticket--);
            }//if
        }//for
    }//run
}//MyThread

public class Prac01{
    public static void main(String[] args){
        MyThread mt1 = new MyThread("A");
        MyThread mt2 = new MyThread("B");
        MyThread mt3 = new MyThread("C");
        mt1.start();
        mt2.start();
        mt3.start();
    }//main
}//Prac01
run:
线程卖票后A还剩几张票-5
线程卖票后A还剩几张票-4
线程卖票后A还剩几张票-3
线程卖票后A还剩几张票-2
线程卖票后A还剩几张票-1
线程卖票后B还剩几张票-5
线程卖票后B还剩几张票-4
线程卖票后B还剩几张票-3
线程卖票后B还剩几张票-2
线程卖票后C还剩几张票-5
线程卖票后C还剩几张票-4
线程卖票后C还剩几张票-3
线程卖票后C还剩几张票-2
线程卖票后C还剩几张票-1
线程卖票后B还剩几张票-1
成功构建 (总时间: 0 秒)
可以看出Thread实现的几个线程分别卖了票。并没有公用票仓。

用Runnable接口实现的话

package prac01;

class MyThread implements Runnable{
    private String name;
    private int ticket=5;
    public MyThread(String name){
        this.name = name;
    }//constructor
    public void run(){
        for(int i=0;i<100;i++){
            if(ticket>0){
                System.out.println("线程"+name+"卖票后还剩"+ticket--+"张");
            }//if
        }//for
    }//run
}//MyThread

public class Prac01{
    public static void main(String[] args){
        MyThread mt = new MyThread("线程");
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }//main
}//Prac01

run:
线程线程卖票后还剩5张
线程线程卖票后还剩3张
线程线程卖票后还剩4张
线程线程卖票后还剩1张
线程线程卖票后还剩2张
成功构建 (总时间: 0 秒)

可以看出通过一个公用一个Runnable对象，来实现对票仓的共享。

如果用Ruunable并行，不共享，只需要把不同的Runnable对象传递给不同的Thread构造方法即可

 

综上，Runnable适合多个相同程序代码的线程去处理同一资源的情况，可以避免单继承的局限，

同时代码被多个线程共享，代码和数据是独立的，更加健壮。

开发时尽可能使用Runnable实现多线程操作。