进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含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());
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
