首先讲一下进程和线程的区别:
进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。
线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。
线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。
多进程是指操作系统能同时运行多个任务(程序)。
多线程是指在同一程序中有多个顺序流在执行。
在java中创建一个线程有两种方法:
①实现java.lang.Runnable接口,重写run()方法,启动:new Thread(this).start()。
要注意的是:
1.r.run()并不是启动线程,而是简单的方法调用。
2.Thread也有run()方法,如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
3.并不是一启动线程(调用start()方法)就执行这个线程,而是进入就绪状态,什么时候运行要看CUP。
②继承java.lang.Thread类,重写run()方法。
虽然两种方法都可行,但是最好还是用第一种方法,因为使用接口灵活性好,java中时单继承、多实现。
Thread类中常用的方法有:
①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。
②join():指等待t线程终止。也可以理解为将t线程合并到当前线程来,等待t线程结束后再往下执行。相当于方法调用
运行该程序结果为:
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是tina线程
我是tina线程
我是main线程
我是main线程
我是main线程
我是main线程
可以看到从第22行起就开始顺序执行了,因为i=10的时候就将该形成合并了。
③yield():暂停当前正在执行的线程对象,并执行其他线程。
④setPriority(): 更改线程的优先级。
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
当代码中(2)(3)处都注释掉之后,yt1,yt2是一样的等级,这时候其实看不出在i=30的时候有什么区别。
没有(2)(3)条注释的情况下:多次运行会发现yt1这个进程抢cpu的技术比较高,每次都先完成。
max-----26
max-----27
max-----28
max-----29
max-----30
I am max----30
max-----31
max-----32
max-----33
max-----34
但是也有可能是yt2先执行到30,多次执行的结果我就不贴图了,因为yield()方法只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行了!
yield相对难理解一些,我在网上看到一个很形象的比喻:“就是说当一个线程使用了这个方法之后,他就把自己的cpu时间让掉,让自己或者其他的线程运行。就好像说这个线程轮到他上厕所了,然后他说“我要和大家来个竞赛',然后所有的人在同一起跑线冲向厕所。。。。有可能是别人进去了,也有可能他自己有抢到了。我们还知道线程有个优先级的问题,那么手里有优先权的这些人就一定能抢到厕所的位置吗? 不一定的,他们只是概率上大些,也有可能没特权的抢到了。” 借此就能很好地理解yield了。
⑤interrupt():中断某个线程,这种结束方式比较粗暴,如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程,会导致资源无法关闭
要想结束进程最好的办法就是用sleep()函数的例子程序里那样,在线程类里面用以个boolean型变量来控制run()方法什么时候结束,run()方法一结束,该线程也就结束了。
⑥还有很多的方法就不一一列举了.........
当然,多线程难点不在这些,多线程的难点在于多线程之间的协调。关于多线程的协调待续
进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。
线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。
线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。
多进程是指操作系统能同时运行多个任务(程序)。
多线程是指在同一程序中有多个顺序流在执行。
在java中创建一个线程有两种方法:
①实现java.lang.Runnable接口,重写run()方法,启动:new Thread(this).start()。
package com.taobao.tina.test;
/**
* @author Tina
*
*/
public class ThreadTest1 {
public static void main(String[] args) {
Runnable1 r = new Runnable1();
//r.run();并不是线程开启,而是简单的方法调用
Thread t = new Thread(r);//创建线程
//t.run(); //如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
t.start(); //线程开启
for (int i = 0; i < 100; i++) {
System.out.println("main:"+i);
}
}
}
class Runnable1 implements Runnable{
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Thread-----:"+i);
}
}
}
要注意的是:
1.r.run()并不是启动线程,而是简单的方法调用。
2.Thread也有run()方法,如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
3.并不是一启动线程(调用start()方法)就执行这个线程,而是进入就绪状态,什么时候运行要看CUP。
②继承java.lang.Thread类,重写run()方法。
package com.taobao.tina.test;
/**
* @author Tina
*
*/
public class ThreadTest2 {
public static void main(String[] args) {
Thread1 t = new Thread1();
//t.run(); //这里也不能直接调用方法
t.start();
for (int i = 0; i < 100; i++) {
System.out.println("main:"+i);
}
}
}
//尽量使用实现Runnnable接口,因为接口比较灵活
class Thread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Thread-----:"+i);
}
}
}
虽然两种方法都可行,但是最好还是用第一种方法,因为使用接口灵活性好,java中时单继承、多实现。
Thread类中常用的方法有:
①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。
package com.taobao.tina.test;
import java.util.Date;
/**
* @author Tina
*
*/
public class SleepTest {
public static void main(String[] args) {
Thread2 t = new Thread2();
t.start();
try {
Thread.sleep(10000); //主线程睡眠10秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
//主线程睡眠10秒钟后结束t线程
//t.interrupt(); //这种结束方式比较粗暴,如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程,会导致资源无法关闭
//t.stop();也是结束某个线程,这种方式比interrupt()更粗暴
t.flag = false;
}
}
class Thread2 extends Thread{
boolean flag = true; //用这种方式结束线程很不错,用一个变量控制run方法什么时候不再执行,不会出现run方法没有执行完毕就结束
@Override
public void run() { //run方法一结束,整个线程就终止了
while(flag){
System.out.println("---"+new Date()+"---");
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
package com.taobao.tina.test;
import java.util.Date;
/**
* @author Tina
*
*/
public class SleepTest {
public static void main(String[] args) {
Thread2 t = new Thread2();
t.start();
try {
Thread.sleep(10000); //主线程睡眠10秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
//主线程睡眠10秒钟后结束t线程
//t.interrupt(); //这种结束方式比较粗暴,如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程,会导致资源无法关闭
//t.stop();也是结束某个线程,这种方式比interrupt()更粗暴
t.flag = false;
}
}
class Thread2 extends Thread{
boolean flag = true; //用这种方式结束线程很不错,用一个变量控制run方法什么时候不再执行,不会出现run方法没有执行完毕就结束
@Override
public void run() { //run方法一结束,整个线程就终止了
while(flag){
System.out.println("---"+new Date()+"---");
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
②join():指等待t线程终止。也可以理解为将t线程合并到当前线程来,等待t线程结束后再往下执行。相当于方法调用
package com.taobao.tina.test;
/**
* @author Tina
*
*/
public class TestJoin {
public static void main(String[] args) {
Thread t = new Thread3("abc");
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("我是tina线程");
if(i==5){
try {
t.join();
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Thread3 extends Thread{
public Thread3(String s) { //给该线程取一个名字,用getName()方法可以去到该名字
super(s);
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("我是"+getName()+"线程");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行该程序结果为:
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是main线程
我是tina线程
我是tina线程
我是tina线程
我是tina线程
我是main线程
我是main线程
我是main线程
我是main线程
可以看到从第22行起就开始顺序执行了,因为i=10的时候就将该形成合并了。
③yield():暂停当前正在执行的线程对象,并执行其他线程。
④setPriority(): 更改线程的优先级。
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
package com.taobao.tina.test;
/**
* @author Tina
*
*/
public class YieldTest extends Thread{
public YieldTest(){
}
public YieldTest(String name){
super(name);
}
@Override
public void run() {
for(int i=0;i<=50;i++){
System.out.println(""+this.getName()+"-----"+i);
if(i==30){
this.yield();
System.out.println("I am "+this.getName()+"----"+i);//(1)
}
}
}
public static void main(String[] args) {
YieldTest yt1=new YieldTest("max"); //优先级高不代表占用所有cpu时间
YieldTest yt2=new YieldTest("min");
yt1.setPriority(Thread.MAX_PRIORITY); //(2)
yt1.start();
yt2.setPriority(Thread.MIN_PRIORITY); //(3)
yt2.start();
}
}
当代码中(2)(3)处都注释掉之后,yt1,yt2是一样的等级,这时候其实看不出在i=30的时候有什么区别。
没有(2)(3)条注释的情况下:多次运行会发现yt1这个进程抢cpu的技术比较高,每次都先完成。
max-----26
max-----27
max-----28
max-----29
max-----30
I am max----30
max-----31
max-----32
max-----33
max-----34
但是也有可能是yt2先执行到30,多次执行的结果我就不贴图了,因为yield()方法只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行了!
yield相对难理解一些,我在网上看到一个很形象的比喻:“就是说当一个线程使用了这个方法之后,他就把自己的cpu时间让掉,让自己或者其他的线程运行。就好像说这个线程轮到他上厕所了,然后他说“我要和大家来个竞赛',然后所有的人在同一起跑线冲向厕所。。。。有可能是别人进去了,也有可能他自己有抢到了。我们还知道线程有个优先级的问题,那么手里有优先权的这些人就一定能抢到厕所的位置吗? 不一定的,他们只是概率上大些,也有可能没特权的抢到了。” 借此就能很好地理解yield了。
⑤interrupt():中断某个线程,这种结束方式比较粗暴,如果t线程打开了某个资源还没来得及关闭也就是run方法还没有执行完就强制结束线程,会导致资源无法关闭
要想结束进程最好的办法就是用sleep()函数的例子程序里那样,在线程类里面用以个boolean型变量来控制run()方法什么时候结束,run()方法一结束,该线程也就结束了。
⑥还有很多的方法就不一一列举了.........
当然,多线程难点不在这些,多线程的难点在于多线程之间的协调。关于多线程的协调待续