Java基础多线程

定义线程的两种方式

1：继承Thread
2：实现Runnable接口
创建线程对象也有两种方法

1：继承Thread类定义线程
采用这种方式最重要的一点就是需要重写Thread中的run方法。
Example

Public class XianCheng extends Thead
{
　　public void run(){
　　　　System.out.println("通过继承Thread定义线程");
　　}
}

重写的run方法可以作为一般方法调用，run方法也可以被重载，但这两种运行的，都不作为一个线程，而是作为主线程的一部分。

创建线程对象：

XianCheng = new Xiancheng();

2:实现Runnable接口定义线程

public class XianCheng2 implements Runnable
{
　　public void run(){
　　　　System.out.println("通过实现Runnable接口定义线程");
　　}

}

用这种方法创建线程，必须借助Thread类。

创建对象:

XianCheng2 xc = new XianCheng();
Thread t = new Thread(xc);

运行线程

线程创建之后只是普通的对象，要想让它作为线程启动，必须进行启动。

Example：

class MyRunnable implements Runnable
{
          public void run(){
                System.out.println("正确启动线程"); 
         }
}    
public class XianCheng4
{
          public static void main(String args[]){
                    MyRunable mr = new MyRunnable();
                    Thread  t = new Thread(mr);
                    t.start();
          }
}    

同时运行多个线程

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("@");
        }
    }
}

class MyRunnable2 implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("#");
        }
    }
}

public class XianCheng6{
    public static void main(String arg[]){
        MyRunnable mr1 = new MyRunnable();
        MyRunnable2 mr2 = new MyRunnable2();
        Thread t1 = new Thread(mr1);
        Thread t2 = new Thread(mr2);
        t1.start();
        t2.start();
    }
    
}

线程调度的方法

线程调度有以下几种方法：睡眠方法，设置线程优先级，Yield让步方法，Join让步方法

睡眠方法： 并不是线程调用sleep方法，而是线程执行sleep方法。

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("@");
            try{
                Thread.sleep(50);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class MyRunnable2 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("#");
            try{
                Thread.sleep(50);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class thread{
    public static void main(String arg[]){
        MyRunnable mr1 = new MyRunnable();
        MyRunnable2 mr2 = new MyRunnable2();
        Thread t1 = new Thread(mr1);
        Thread t2 = new Thread(mr2);
        t1.start();
        t2.start();
        
    }
    
}

设置优先级：默认优先级是5，java中优先级1-10.调用setPriority(int i)可以设置优先级

public final void setPriority(int i);

Example:

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("@");
        }
    }
}

class MyRunnable2 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("#");
        }
    }
}

public class thread{
    public static void main(String arg[]){
        MyRunnable mr1 = new MyRunnable();
        MyRunnable2 mr2 = new MyRunnable2();
        Thread t1 = new Thread(mr1);
        Thread t2 = new Thread(mr2);
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
        
    }
    
}

yield让步方法:yield可以让当前运行的线程让出当前cpu，使线程回到准备状态，让其他线程进入运行状态，而将cpu给哪个线程并不确定，由系统决定。

需要线程执行yield方法。

public static void yield();

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("@");
            Thread.yield();
        }
    }
}

class MyRunnable2 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.print("#");
            Thread.yield();
        }
    }
}

public class thread{
    public static void main(String arg[]){
        MyRunnable mr1 = new MyRunnable();
        MyRunnable2 mr2 = new MyRunnable2();
        Thread t1 = new Thread(mr1);
        Thread t2 = new Thread(mr2);
        t1.start();
        t2.start();
    }
}

join让步方法:使用join可以将cpu让步给指定线程。当一个线程必须在另一个线程执行完成后才能运行的时候可以使用join让步方法。

public final void join() throws InterruptedException;

public final void join(long mills)throws InterruptedException;

public final void join(long mills,int nanos) throws InterruptedException;

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0;i<20;i++){
            System.out.print("@");
        }
    }
}

public class thread{
    public static void main(String arg[]){
        MyRunnable mr1 = new MyRunnable();
        Thread t1 = new Thread(mr1);
        t1.start();
        for(int i=0;i<100;i++){
            if(i==10){
                try{
                    t1.join();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.print("#");
        }
    }
    
}

wait,notify,notifyall

    是Object 类的方法。所有对象都拥有这一对方法。这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。

notify（）是释放对象的wait（）方法而阻塞线程（但是也要当得到锁后才可以运行）但是这个释放是随机的，也就是不一定要释放那个线程。（因为调用同一资源的可能不是一个线程或者说是有多个阻塞的线程在等待，但是如果加了synchronized也只有一个线程，也有其他的线程在等待中，也就是阻塞）我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。 
除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。 
　　同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现 IllegalMonitorStateException 异常。

 举例：生产者与消费者

public class ProducerConsumer {
    public static void main(String args[]){
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        new Thread(p).start();
        new Thread(c).start();
    }
}
class WoTou{
    int id ;
    public WoTou(int id){
        this.id = id;
    }
    public String toString(){
        return "WoTou:"+id;
    }
}
class SyncStack{
    int index = 0;
    WoTou[] awtWT = new WoTou[6];
    
    public synchronized void push(WoTou wt){
        while(index == awtWT.length){
            try {
                this.wait();//当前的正在访问对象的线程wait
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        awtWT[index] = wt;
        index ++; 
    }
    
    public synchronized WoTou pop(){
        while(index == 0){//if->while：如果catch住异常后，假如是if并且index=0，index == 0 不再判断，index--会执行， 程序错误。所以改为while,可以避免发生如此错误。
            try {
                this.wait();//当前的正在访问对象的线程阻塞（wait）,wait后对象的锁不归线程所有，直到"醒了"（notify,notifyALL），再重新找回锁。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();//叫醒一个正在当前对象上wait的线程。
        index--;
        return awtWT[index];
    }
}

class Producer implements Runnable{
    SyncStack ss = null;
    Producer(SyncStack ss){
        this.ss = ss;
    }
    public void run() {
        for(int i=0;i<20;i++){
            WoTou wt = new WoTou(i);
            ss.push(wt);
            System.out.println("Producer："+wt);
            try {
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }    
    }
}
class Consumer implements Runnable{
    SyncStack ss = null;
    Consumer(SyncStack ss){
        this.ss = ss;
    }
    public void run() {
        for(int i=0;i<20;i++){
            WoTou wt = ss.pop();
            System.out.println("Consumer："+wt);
            try {
                Thread.sleep((int)(Math.random()*1000));//目的是让其他线程有执行的机会。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }    
    }
}
执行结果： 

Producer：WoTou:0
Consumer：WoTou:0
Producer：WoTou:1
Producer：WoTou:2
Producer：WoTou:3
Producer：WoTou:4
Producer：WoTou:5
Producer：WoTou:6
Consumer：WoTou:6
Producer：WoTou:7
Producer：WoTou:8
Consumer：WoTou:7
Producer：WoTou:9
Consumer：WoTou:8
Consumer：WoTou:9
Producer：WoTou:10
Consumer：WoTou:10
Producer：WoTou:11
Consumer：WoTou:11
Producer：WoTou:12
Consumer：WoTou:12
Producer：WoTou:13
Consumer：WoTou:13
Producer：WoTou:14
Consumer：WoTou:14
Producer：WoTou:15
Consumer：WoTou:15
Producer：WoTou:16
Consumer：WoTou:16
Producer：WoTou:17
Consumer：WoTou:17
Producer：WoTou:18
Consumer：WoTou:18
Producer：WoTou:19
Consumer：WoTou:19
Consumer：WoTou:5
Consumer：WoTou:4
Consumer：WoTou:3
Consumer：WoTou:2
Consumer：WoTou:1