Java多线程（1）-线程的创建和使用

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。
线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

线程和进程一样分为五个阶段：创建 ，就绪，运行，阻塞，结束

在java中创建一个线程有两种方法：
1 ：实现java.lang.Runnable接口 重写run方法 启动 new Thread(this).start()
2 :  继承java.lang.Thread类，重写run()方法。

注意点：
----

run并不是启动线程，而是简单的方法调用 
并不是一启动线程（调用start()方法）就执行这个线程，而是进入就绪状态，什么时候运行要看CUP
虽然两种方法都可行，但是最好还是用第一种方法，因为使用接口灵活性好，java中时单继承、多实现。
Runnable可以多个线程共享同一资源

实现Runnable接口如下
package com.test.Thread;
/**
 * 多线程
 * @author admin
 * 2017年3月21日
 * 
 */
public class Thread1 implements Runnable{
     private String name;  
     public Thread1(String name) {  
           this.name=name;  
       }  


    @Override
    public void run() {
       try {  
         for (int i = 0; i < 5; i++) {  
                System.out.println(name + "运行  :  " + i);        
                Thread.sleep((int) Math.random() * 10);

            }  
          } catch (Exception e) {  
                e.printStackTrace();  
       }  

    }

    public static void main(String[] args) {
         new Thread(new Thread1("C")).start();  
         new Thread(new Thread1("D")).start();    
    }
}


线程中的常用方法如下
1  sleep(long mills) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行 也就是阻塞状态）让出位置 让其它线程进入执行 等休眠时间过后会再次进入就绪状态等待cpu执行

package com.test.Thread;
import java.util.Date;
public class SleepTest implements Runnable{
//用这种方式结束线程很不错，用一个变量控制run方法什么时候不再执行，不会出现run方法没有执行完毕就结束
boolean flag = true;
@Override
public void run() {
while(flag){
System.out.println(“—”+new Date()+”—”);
try {
Thread.sleep(10000); //主线程睡眠10秒钟
} catch (InterruptedException e) {
return;
}
}
}
public static void main(String[] args) {
SleepTest test=new SleepTest();
Thread t=new Thread(test);
t.start();
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
test.flag = false;
}

}

2  join():指等待t线程终止。也可以理解为将t线程合并到当前线程来，等待t线程结束后再往下执行。相当于方法调用

package com.test.Thread;

/*
 * t.join()方法指等待t线程终止。也可以理解为将t线程合并到当前线程来，等待t线程结束后再往下执行。相当于方法调用
 */
public class TestJoin {
    public static void main(String[] args) {
        Thread t = new Thread3("abc");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我是main线程");
            if(i==10){
                try {
                    t.join();
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
class Thread3 extends Thread{
    public Thread3(String s) { //给该线程取一个名字，用getName()方法可以去到该名字
        super(s);
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我是"+getName()+"线程");
            try {
                sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}


3  yield():暂停当前正在执行的线程对象，并执行其他线程。

package com.test.Thread;


/*t.yield()暂停当前正在执行的线程对象，并执行其他线程。
 * 
 * MIN_PRIORITY 1
 * NORM_PRIORITY 5
 * MAX_PRIORITY 10
 */
public class TestYield {
    public static void main(String[] args) {
        Thread4 t1 = new Thread4("t1");
        Thread4 t2 = new Thread4("t2");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        t1.start();
        t2.start();

    }
}
class Thread4 extends Thread{
    public Thread4(String s) { 
        super(s);
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我是"+getName()+"线程"+i);
            if(i%10 == 0){
                yield();
            }
        }
    }
}


4  setPriority(): 更改线程的优先级。
　MIN_PRIORITY = 1
   NORM_PRIORITY = 5
    MAX_PRIORITY = 10


5  interrupt():中断某个线程，这种结束方式比较粗暴，如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程，会导致资源无法关闭 要想结束进程最好的办法就是用sleep()函数的例子程序里那样，在线程类里面用以个boolean型变量来控制run()方法什么时候结束，run()方法一结束，该线程也就结束了。


什么是守护线程？
调用thread.setDaemon(true)方法当前线程会变为守护线程且后续创建的新线程也都是守护线程
主线程退出 守护线程也会随着退出


package com.test.Thread;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Scanner;

/**
 * 守护线程
 * @author admin
 * 2017年3月22日
 * 调用thread.setDaemon(true)方法当前线程会变为守护线程且后续创建的新线程也都是守护线程
    主线程退出 守护线程也会随着退出

 */
public class DaemonThread implements Runnable{

    @Override
    public void run() {
        System.out.println("进入守护线程 "+Thread.currentThread().getName());     
        try {
            writeToFile();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("退出守护线程 "+Thread.currentThread().getName());

    }
    private void writeToFile() throws Exception{
        File file=new File("e:"+File.separator+"deamon.txt");
        OutputStream out=new FileOutputStream(file,true);
        int count=0;
        while(count<999){
            out.write(("\r\nword"+count).getBytes());
            System.out.println("守护线程"+Thread.currentThread().getName()+"向文件写入word"+count++);
            Thread.sleep(1000);

        }       
    }

    public static void main(String[] args) {
        System.out.println("进入主线程"+Thread.currentThread().getName());
        DaemonThread damon=new DaemonThread();
        Thread t=new Thread(damon);
        t.setDaemon(true);
        t.start();
        Scanner s=new Scanner(System.in);
        s.next();
        System.out.println("退出主线程"+Thread.currentThread().getName());
    }
}