Java 线程

线程：一个程序的内部控制流

    概念：线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

进程：

线程和进程区别：

    1、进程拥有独立的代码和数据空间，进程切换开销较大；同一进程中的线程共享代码和数据空间，线程切换开销较小；

   2、多进程：能同时运行多个任务（程序）；多线程：同一进程中多个顺序流同时执行；

   3、一个线程可以创建和撤消另一个线程；同一进程中的多个线程之间可以并发执行；

    4、线程作为调度和分配的基本单位；进程作为拥有资源的基本单位；

关系：

    1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程；

    2、资源分配给进程，同一进程的所有线程共享该进程的所有资源；

    3、处理机分给线程，即真正在处理机上运行的是线程；

    4、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体

Java中线程的创建：

    java.lang.thread类：一个thread对象即代表一个线程

   run方法：执行线程内部的操作；

   start方法：启动线程

创建线程的方法1: 实现Runnable接口

import java.lang.*;


public class TestThread1 {
    public static void main(String[] args) {
        Runner1 r1 = new Runner1();
        Runner2 r2 = new Runner2();


        /*实现Runnable接口，需要创建Thread对象，才能调用start方法
        //r1.run();
        //直接调用run方法，子线程先执行，执行完毕即继续执行主线程
        
        Thread t = new Thread(r1);
        t.start();
        //线程启动，通知cpu开始执行此线程
        */


        //继承Thread类，可以直接调用start方法
        r2.start();
        
        for(int i = 0; i < 100; i++) {
            System.out.println("Main Thread-------- " + i);
        }


    }
}


//创建线程的方法1:实现Runnable接口
class Runner1 implements Runnable {
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("Runner1: " + i);
        }                                  
    }
}


//创建线程的方法2:继承Thread类
class Runner2 extends Thread {
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("Runner2: " + i);
        }
    }
}

创建线程的方法2: 继承Thread类

线程的状态：

线程的基本控制方法：

sleep方法：静态方法，被打断会抛出异常

import java.lang.*;
import java.util.*;

public class TestSleep {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        try {Thread.sleep(10000);}
        //主线程（main）睡眠
        catch (InterruptedException ex) {}

        thread.interrupt();
        //打断子线程
        //不适合用来结束线程 
    }
}

class MyThread extends Thread {
    public void run() {
        while(true) {
            System.out.println("===" + new Date() + "===");
            try {
                sleep(1000);
            } catch (InterruptedException ex) {
                return;
            }
        }
    }
}

join方法：合并某个线程

public class TestJoin {
    public static void main(String[] args) {
        MyThread thread = new MyThread("abcde");
        thread.start();

        try {
            thread.join();
            //将子线程合并进来，即等待子线程执行完毕
        } catch (InterruptedException ex) {

        }

        for(int i = 0; i < 10; i++) {
            System.out.println("i am main thread");
        }       
    }
}

class MyThread extends Thread {
    MyThread(String s) {
        super(s);
    }
    //给线程起名字

    public void run() {    
        for(int i = 0; i < 10; i++) {
            System.out.println("i am " + getName());
            try {
                sleep(1000);
            } catch (InterruptedException ex) {
                return;
            }
        }
    } 
}

yield方法：让出cpu，让其他线程执行

public class TestYield {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("---t1");
        MyThread thread2 = new MyThread("t2");

        thread1.start();
        thread2.start();
    }
}

class MyThread extends Thread {
    MyThread(String s) {
        super(s);
    }

    public void run() {
        for(int i = 1; i <= 100; i++) {   
            System.out.println(getName() + " " + i);
            if(i % 10 == 0) {
                //能被10整除时，立马让其他线程执行
                yield();
            }
        }
    }
}

线程的优先级：

    优先级越高，得到的cpu执行时间片越长，范围1-10，默认为5

public class TestPriority {
    public static void main(String[] args) {
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());

        t1.setPriority(Thread.NORM_PRIORITY + 3);
        //设置优先级
        t1.start();
        t2.start();
    }
}

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

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