Java线程中的基本方法总结

1、线程和进程

<1>线程是一个程序内部的顺序控制流
<2>线程和进程的基本区别：
进程是一个静态的概念，我们平时所说的进程的执行其实是线程的执行，进程包含线程
每个进程都有独立的代码和数据空间（进程上下文），进程的切换会有较大的开销。
线程可以理解为轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（pc），线程的开销较小。
多进程：操作系统中同时运行多个程序。
多线程：同一个应用程序中有多个顺序流同时执行。

2、java中的多线程

<1>java的线程是通过java.lang.Thread类来实现的。
<2>可以通过创建Thread的对象实例来创建新的线程。
<3>VM启动时会有一个主线程，也就是main方法。
<4>每个线程都是通过Thread对象的run()方法来完成操作的，run被称为线程体。
<5>通过调用Thread的start方法来启动一个线程。

3、java中线程的创建和启动

第一种方法：Runnable接口

1、定义线程类实现Runnable接口。
2、Thread myThread = new Thread(target);target为Runnable接口类型
3、Runnable接口中有一个方法：
public void run() 用来定义线程运行体。
4、使用Runnable接口可以为多个线程提供共享的数据
5、在实现Runnable接口的类的run方法中可以使用Thread的静态方法：
public static Thread currentThread()获取当前线程的使用。

看看一段代码：

public class TestThread01 {

public static void main(String[] args) {
    Runner1 r = new Runner1();
    r.run();
    for(int i=0;i<10;i++){
        System.out.println("Main:"+i);
    }
}
}
class Runner1 implements Runnable{
public void run(){
    for(int i=0;i<10;i++){
        System.out.println("Runner1:"+i);
    }
}
}

上面这段代码我们来说明什么叫做方法调用？在main方法里，我们会先去执行run方法，然后再去执行main里面的输出。
在看一段代码：

public class TestThread01 {

public static void main(String[] args) {
    Runner1 r = new Runner1();
    Thread myThread = new Thread(r);
    myThread.start();
    for(int i=0;i<10;i++){
        System.out.println("Main:"+i);
    }
}
}
class Runner1 implements Runnable{
public void run(){
    for(int i=0;i<10;i++){
        System.out.println("Runner1:"+i);
    }
}
}

上面的这段代码中，我们新开了一个线程，将之前继承Runnable接口的类的实例传了进去，并且去调用了它的start方法，这个时候程序就要告诉cpu，我这会有一个新的线程，于是这个新的线程就会去调用传进来的对象的run方法，执行过程是main中的输出和run中的输出交替执行。这也就是多线程，主线程和子线称交替运行。

线程创建和启动的第二种方法：继承Thread类

写一个线程类并且继承于Thread类，然后重写其run方法，之后再就可以直接新建线程对象了。

直接看代码：

public class TestThread01 {

public static void main(String[] args) {
    Runner1 r = new Runner1();
    r.start();
    for(int i=0;i<10;i++){
        System.out.println("Main:"+i);
    }
}
}
class Runner1 extends Thread{
public void run(){
    for(int i=0;i<10;i++){
        System.out.println("Runner1:"+i);
    }
}
}

上面的程序运行也是：两个线程交替运行，但是分的时间片不一定相同，所以说两者并没有明显的优先级问题。

总结：能实现Runnable接口就使用第一种方法，尽量不要去继承Thread类，这是首要原则。

4、线程的状态转换

线程调用了start方法，只是向cpu去宣告已经准备好，并不是立即去执行该线程，cpu在空闲的时候就会分给该线程一些时间片，然后去调度一会该线程。

看一些常用的线程的方法：

sleep方法：

Thread的静态方法：
public static void sleep（long mills）throws InterruptedException
使得当前线程休眠，暂停mills毫秒
由于是静态方法，可以有Thread.sleep()直接调用
在哪个线程里调用sleep方法，哪个线程就休眠

看一段代码来熟悉一下该方法的使用：

public class TestThread01 {

public static void main(String[] args) {
    myThread t = new myThread();
    t.start();
    try {
        Thread.sleep(10000);//主线程睡眠
        //在哪个线程里调用sleep方法，哪个线程就休眠
    } catch (InterruptedException e) { }
    t.interrupt();
}
}
class myThread extends Thread {
public void run() {
    System.out.println(new Date());
    try {
        sleep(1000);// 每隔1秒休眠一次，也就是每隔一秒打印一次时间
    } catch (InterruptedException e) {

        return;// 只要碰到中断，就结束该线程
    }
}
}

分析一下过程:
先看myThread，run方法中，每隔一秒打印一次时间，遇到异常就会结束。再看主线程，main方法中，主线程休眠10秒钟，也就是只运行10秒钟的myThread，只打印10次时间，10秒钟之后，主线程运行t.interrupt()，也就是使myThread中断，这样就会触发异常，从而结束线程。但是这绝不是好的去结束线程的方法，同时，stop方法也不行，更加粗暴，直接杀死了线程。那我们可以如下去结束一个线程：在线程中定义一个flag=true，while（flag），再去执行相应的方法，如果想结束线程，就直接令myThread.flag = false，就可以了。

join方法：

合并某个线程，相当于方法调用

看代码:

    public static void main(String[] args) {
    myThread t = new myThread("t");
    t.start();
    try {
        t.join();
    } catch (InterruptedException e) {

    }
    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 e) {
            return;
        }
    }
}
}

我们分析一下，如果没有join方法的话，这个程序应该是主线程和副线程交替执行，也就是交替输出name，但是有了join方法，所以在主线程读到join方法时，就会先去执行完myThread线程，再去执行主线程，相当于我们之前的方法调用。

yield方法：

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

看代码：

public class TestThread01 {

public static void main(String[] args) {
    myThread t1 = new myThread("t1");
    myThread t2 = new myThread("t2");
    t1.start();
    t2.start();

}
}
class myThread extends Thread {
myThread(String s){
    super(s);
}
public void run() {
    for(int i=0;i<100;i++){
        System.out.println("i am "+getName()+":"+i);
        if(i%10==0){
            yield();
        }
    }
}
}

上面的代码中，创建了两个线程，还有一个主线程，两个线程交替执行，只不过在i为10的整数倍的时候，线程就会让出cpu给另一个线程去执行。

5、线程的优先级

<1>java提供一个线程调度器来监控程序中启动后进入就绪状态的线程，调度器按照线程的优先级来决定调用线程的顺序。
<2>线程的优先级用数字表示，1-10，默认优先级是5。
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
<3>使用以下方法来获得或设置线程的优先级：
int getPriority()
void setPriority(int newPriority)

看一段代码：

public class TestThread01 {

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<100;i++){
        System.out.println("T1:"+i);

    }
}
}
class T2 implements Runnable {

public void run() {
    for(int i=0;i<100;i++){
        System.out.println("T2:"+i);

    }
}
}

以上代码中如果没有t1.setPriority(Thread.NORM_PRIORITY+3)这一行，那么就会交替执行，但是在加了这一句之后，t1的优先级就会高，所以会先执行t1一段时间，在执行t2一小段。不是纯粹的执行完t1再去执行t2。