java-线程

线程是一个程序里面不同的执行路径（理解这个就可以了）

1.线程的基本概念
可以通过创建Thread的实例来创建新的线程。
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。
通过调用Thread类的start()方法来启动一个线程。

2.线程的创建和启动
第一种
定义线程类实现Runnable接口
Thread myThread = new Thread(target) //target为Runnable接口类型。
Runnable中只有一个方法：
public void run();//用以定义线程运行体。
使用Runnable接口可以为多个线程提供共享的数据。
在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法:
public static Thread currentThread() //获取当前线程的引用。

第二种
可以定义一个Thread的子类并重写其run方法：
class MyThread extends Thread{
public void run(){...}
}
然后生成该类的对象：
MyThread myThread = new MyThread(...)

例子1：使用Runnable接口实现

//main主线程和子线程并行执行
public class TestThread1 {
    public static void main(String[] args) {
        Runnable1 r = new Runnable1();
        //r.run();//方法调用
        Thread thread = new Thread(r);
        thread.start();//启动一个新线程
        for(int i=0;i<100;i++){
            System.err.println("MainThread-----"+i);
        }
    }
}

class Runnable1 implements Runnable {
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Runner1:"+i);
        }
    }
}

 例子2：从Thread类继承

//main主线程和子线程并行执行
public class TestThread1 {
    public static void main(String[] args) {
        Runnable1 thread = new Runnable1();
        thread.start();//启动一个新线程
        for(int i=0;i<100;i++){
            System.err.println("MainThread-----"+i);
        }
    }
}

class Runnable1 extends Thread{
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Runner1:"+i);
        }
    }
}

3.常用方法

sleep方法
可以调用Thread的静态方法：
public static void sleep(long milis) throws InterruptedExecption使得当前线程休眠（暂时停止执行millis毫秒）。
由于是静态方法，sleep可以由类名之间调用：
Thread.sleep(...)

例子3

public class TestInterrupt {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(10000);//在哪个线程里调用Thread.sleep方法就让哪个线程睡眠
        } catch (InterruptedException e) {}
        thread.interrupt();//子线程结束(不是让子线程结束的最好的方法，比较粗暴，可能会导致打开的资源来不及关)
        //thread.stop();//(已废弃)方式比interrupt更粗暴。
    }
}

class MyThread extends Thread{
    @Override
    public void run() {//不可以在后面写throws exception,原因是run重写的，重写的方法不能抛出比被重写方法不同的异常
        while(true){
            System.err.println("===="+new Date()+"====");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

例子4：使用一个变量控制子程序结束

public class TestInterrupt {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {}
        thread.flag = false;
    }
}

class MyThread extends Thread{
    boolean flag = true;//定义一个变量来控制
    public void run() {
        while(flag){
            System.err.println("===="+new Date()+"====");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

join方法

合并某个线程

例子5

public class TestJoin {
    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2("t1");
        t1.start();
        try {
            t1.join();//合并t1,把t1合并到主线程来，等t1执行完才执行主线程的
        } catch (Exception e) {}
        for(int i=0;i<10;i++){
            System.err.println("main Thread is "+i);
        }
    }
}

class MyThread2 extends Thread{
    public MyThread2(String s) {
        super(s);
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.err.println("i am "+getName());
            try {
                sleep(1000);
            } catch (Exception e) {
                return;
            }
        }
    }
}

yield方法（用的不多）

让出CPU，给其他线程执行的机会

例子6

public class TestYeild {
    public static void main(String[] args) {
        MyThread3 thread3 = new MyThread3("t3");
        MyThread3 thread1 = new MyThread3("t1");
        thread3.start();
        thread1.start();
    }
}

class MyThread3 extends Thread{
    public MyThread3(String s) {
        super(s);
    }
    @Override
    public void run() {
        for(int i=0;i<50;i++){
            System.err.println(getName()+"-----"+ i);
            if (i%10==0) {
                yield();
            }
        }
    }
}

线程的优先级别

用数字表示，范围从1到10，默认是5，优先级越高的得到的CPU的执行的时间片就会越多。

例子6

public class TestPriority {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new t1());
        Thread thread2 = new Thread(new t2());
        thread1.setPriority(Thread.NORM_PRIORITY+3);
        thread1.start();
        thread2.start();
    }
}

class t1 implements Runnable {
    public void run() {
        for(int i=0;i<10;i++){
            System.err.println("t1:"+i);
        }
    }
}

class t2 implements Runnable {
    public void run() {
        for(int i=0;i<10;i++){
            System.err.println("--------t2:"+i);
        }
    }
}

执行结果

t1:0
t1:1
--------t2:0
t1:2
t1:3
t1:4
t1:5
t1:6
t1:7
t1:8
t1:9
--------t2:1
--------t2:2
--------t2:3
--------t2:4
--------t2:5
--------t2:6
--------t2:7
--------t2:8
--------t2:9

4.线程同步

例子7：不使用线程同步会出现以下问题（结果不对）

public class TestSync implements Runnable {
    Timer timer = new Timer();
    public static void main(String[] args) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}

class Timer{
    private static int num =0;
    public void add(String name) {
        num++;
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {}
            System.err.println(name +"你是第"+num+"个使用timer的线程");
        
    }
}

结果

t2你是第2个使用timer的线程
t1你是第2个使用timer的线程

例子8：

public class TestSync implements Runnable {
    Timer timer = new Timer();
    public static void main(String[] args) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}

class Timer{
    private static int num =0;
    public void add(String name) {
    //    public synchronized void add(String name) { //也可以写成这样
        synchronized (this) {//该方法被执行过程中当前对象被锁定
        num++;
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {}
            System.err.println(name +"你是第"+num+"个使用timer的线程");
        }
    }
}

结果

t1你是第1个使用timer的线程
t2你是第2个使用timer的线程

5.多线程会造成的问题

死锁

例子9

public class TestDeadLocak implements Runnable{
    public int flag=1;
    static Object o1=new Object(),o2=new Object();
    
    @Override
    public void run() {
        System.err.println("flag="+flag);
        if (flag==1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.err.println("1");
                }
            }
            
        }
        
        if (flag==0) {
            synchronized(o2){
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.err.println("0");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestDeadLocak t = new TestDeadLocak();
        TestDeadLocak t0 = new TestDeadLocak();
        t0.flag=0;
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t0);
        t1.start();
        t2.start();
    }
}

 6.生产者消费者问题

 例子10

/*
 * 生产者消费者问题
 * 要  点：
 *        1. 共享数据的不一致性/临界资源的保护
 *        2. Java对象锁的概念
 *        3. synchronized关键字/wait()及notify()方法
 */
public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack stack = new SyncStack();
        Runnable p = new Producer(stack);
        Runnable c = new Customer(stack);
        Thread p1 =new Thread(p);
        Thread c1 = new Thread(c);
        p1.start();
        c1.start();
    }
}

class SyncStack{ //支持多线程同步操作的堆栈的实现
    private int index =0;
    private char[] data = new char[6];
    public synchronized void push(char c) {
        if(index == data.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        this.notify();
        data[index] = c;
        index++;
    }
    public synchronized char pop() {
        if(index == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        this.notify();
        index--;
        return data[index];
    }
}

class Producer implements Runnable{
    SyncStack stack;
    public Producer(SyncStack s) {
        stack =s;
    }
    
    @Override
    public void run() {
        for(int i=0;i<20;i++){
             char c =(char)(Math.random()*26+'A');
             stack.push(c);
             System.err.println("producer"+c);
             try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {}
        }
        
    }
    
}

class Customer implements Runnable{
    SyncStack stack;
    public Customer(SyncStack s) {
        stack =s;
    }
    
    @Override
    public void run() {
        for(int i=0;i<20;i++){
             char c =stack.pop();
             System.out.println("消费："+c);
             try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {}
        }
        
    }
}