Java多线程详解

线程（Thread）是指程序的运行流程，多线程机制指同时运行多个程序块。

Java中实现多线程有两种方法：继承Thread类；实现Runnable接口。

Thread类的run()方法的制定者：接口Runnable中的run();

在Thread类中没有完全实现Runnable接口中的run()方法。

Thread类是Runnable接口的子类，Thread类中的run()方法调用的是Runnable接口中的run()方法。

接口是由全局变量和公共抽象方法所组成的。

所以，在Thread子类中，必须覆写Thread类中的run()方法。

启动线程时，不能直接调用run()方法，而是调用从Thread类中继承而来的start()方法；

即同一个对象只能调用一次start方法。

如果一个类继承了Thread类，那么只能调用一次start()方法，如果多次调用，

将会出现“IllegalThreadStateException”异常。

Runnable接口中只有一个方法：run（）；

Runnable、Thread中的run方法和自定义的run方法之间的关系：

interface Runnable{
    public abstract void run();
}                                //remove method body

public class Thread implements Runnable {
    private Runnable target;                //封装
    public Thread(Runnable target,String name){        //构造函数，name是线程的名称
        init(target);
    }
    
    private void init(Runnable target2) {    //检验关口，给属性赋值
        this.target = target;
    }
    
    public void run() {
        if(target != null){
            target.run();    //此run方法指的是自定义的run方法，即Runable中的run方法
                    //整个过程中，只有一个对象，只有这个对象有能力调用自定
                    //义的run方法。
        }    
    }    
}
class MyThread implements Runnable{
    public void run() {                        //自定义的run方法
        
    }
}

由于使用Runable的整个过程中，只产生一个对象，所以可以方便地实现资源的共享。

这也是Runable优于Thread之处。

Java程序每次运行至少启动两个线程：main线程、垃圾收集线程。

Thread类中常用的方法：

currentThread（静态），通过类名Thread直接调用；

判断线程是否启动（存活）

class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+"运行………"+i);
        }
    }
}

public class ThreadAliveDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);   
        System.out.println("线程开始执行之前……"+t.isAlive());
        
        t.start();
        
        for(int i=0;i<5;i++){
            System.out.println("等待……"+i);//i值的不同，最后运行结果不同
        }
        
        System.out.println("线程开始执行之后……"+t.isAlive());
        for(int i=0;i<3;i++){
            System.out.println("main运行……"+i);
        }
        System.out.println("代码执行之后……"+t.isAlive());
    }
}

主线程有可能比其他线程先执行完，其他线程不会受到任何影响，不会随着主线程的结束而结束。

线程的强制执行

class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"运行……"+i);
        }
    }
}

public class ThreadJoinDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
        for(int i=0;i<30;i++){
            if(i>10){
                try{
                    t.join();
                }catch(Exception e){}
            }
            System.out.println("Main线程"+i);
        }
    }
}

线程的休眠：

sleep为静态方法，使用类名Thread直接调用

class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<5;i++){
            try{
                Thread.sleep(1000);//每次输出都会间隔1000ms，达到延迟操作的结果
            }catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"…………"+i);
        }
    }
}

public class ThreadSleepDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt,"线程").start();
    }

}

线程的中断：

class MyThread implements Runnable{
    public void run(){
        System.out.println("进入run方法");
        try{
            Thread.sleep(10000);
            System.out.println("已完成休眠");
        }catch(Exception e){
            System.out.println("休眠被终止");
            return;
        }
        System.out.println("正常结束");
    }
}

public class ThreadInterruptDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
        try{
            Thread.sleep(2000);
        }catch(Exception e){}
        t.interrupt();        
    }
}

在使用join和sleep时，要进行异常处理。

线程的礼让：

class MyThread implements Runnable{
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
            if(i==2){
                System.out.print("线程礼让：");
                Thread.currentThread().yield();
            }
        }
    }
}

public class ThreadYieldDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt,"线程A");
        Thread t2 = new Thread(mt,"线程B");
        t1.start();
        t2.start();
    }
}

每当线程满足条件（i=2）时，本线程就会停止，而让其他线程先执行。

同步：指多个操作在同一时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续进行。

解决资源共享的同步操作，可以使用同步代码块和同步方法两种方式完成。

同步代码块：

class MyThread implements Runnable{
    private int ticket = 20;
    public void run(){
        for(int i=0;i<100;i++){
            synchronized(this){        //将当前对象（this）设置成同步对象
                if(ticket>0){
                    System.out.println(ticket--);
                }
            }
        }
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

同步方法：（使用synchronized关键字将一个方法声明为同步方法）

class MyThread implements Runnable{
    private int ticket = 50;
    public void run(){
        for(int i=0;i<100;i++){
            this.sale();
        }
    }
    private synchronized void sale() {
            if(ticket>0){
                System.out.println(ticket--);
            }
    }
}

public class SynchronizedDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

Java中方法定义的完整格式：

访问权限（public、default、protected、private）[final][static][synchronized]

返回值类型 void 方法名称（参数类型，参数名称）[throws Exception1,Exception2]

{

return 返回值；

}

死锁：指两个线程都在等着彼此先完成，造成了程序的停滞。

卖票：同一个动作处理同一资源

生产者消费者：不同动作处理同一资源

class Info{
    private String name = "zhangsan";
    private String content = "java";
    private boolean flag = false;
    public synchronized void set(String name,String content){
        if(!flag){
            try{
                super.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        this.name = name;
        this.content = content;
        flag = false;
        super.notify();
    }
    public synchronized void get(){
        if(flag){
            try{
                super.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println(name+ ":" +content);
        flag = true;
        super.notify();
    }
}

class Producer implements Runnable{
    private Info info = null;
    public  Producer(Info info){
        this.info = info;
    }
    public void run(){
        boolean flag = false;
        for(int i=0;i<10;i++){
            if(flag){
                this.info.set("zhangsan", "java");
                flag = false;
            }else{
                this.info.set("wangzhi","www");
                flag = true;    
            }
        }
    }
}

class Consumer implements Runnable{
    private Info info = null;
    public Consumer(Info info){
        this.info = info;
    }
    public void run(){
        for(int i=0;i<10;i++){
            try{
                Thread.sleep(100);
            }catch(Exception e){
                e.printStackTrace();
            }
            this.info.get();
        }
    }
}

public class ThreadCaseDemo {

    public static void main(String[] args) {
        Info i = new Info();
        Producer pro = new Producer(i);
        Consumer con = new Consumer(i);
        new Thread(pro).start();
        new Thread(con).start();
    }
}

停止线程运行：在多线程开发中可以通过设置标志位的方式停止一个线程的运行。