线程状态
线程停止
推荐线程自己停下来
建议使用一个标志位进行终止变量当flag=false，则线程终止
public class TestStop implements Runnable{
//1.设置一个标识位(线程中定义线程使用的标识)
private boolean flag = true;
@Override
public void run() {
//2.线程体使用该标识
while (flag){
System.out.println("run.....Thread");
}
}
//3.对外提供方法改变标识
public void stop(){
this.flag=false;
}
}
例题：测试线程停止
package come.demg.state;
//测试stop
//1.建议线程正常停止---》利用次数，不建议死循环
//2.建议使用标志位--》设置一个标志位
//3.不要使用stop或destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
//1.设置一个标识位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run.....Thread"+i++);
}
}
//2.设置一个公开的方法停止线程，转换标志位
public void stop(){
this.flag=false;
}
public static void main(String[] args) {
TestStop testStop =new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if (i==900){
//调用stop方法切换标志位，让线程停止
testStop.stop();
System.out.println("线程该停止了");
}
}
}
}
线程休眠-sleep
1.sleep（时间）指定当前线程阻塞的毫秒数；
2.sleep存在异常InterruptedException;
3.sleep时间到达后线程进入就绪状态；
4.sleep可以模拟网络延时，倒计时等；
5.每一个对象都有一个锁，sleep不会释放锁；
例题：倒计时
package come.state;
//模拟倒计时
public class TestSleep {
public static void main(String[] args) {
try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException{
int num = 10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
}
例题：获取电脑当前时间
package come.state;
import java.text.SimpleDateFormat;
import java.util.Date;
//获取当前系统时间
public class TestSleep2 {
public static void main(String[] args) {
//打印当前系统时间
Date startTime =new Date(System.currentTimeMillis());//获取当前系统时间
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime =new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程礼让-Yield
1.礼让线程，让当前正在执行的线程暂停，但不阻塞
2.将线程从运行状态转为就绪状态
3.cup重新调度，礼让不一定成功！
例题：礼让线程测试
package come.state;
//测试礼让线程
public class TestYield {
public static void main(String[] args) {
MyYield myYield =new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
线程强制执行-Join
1.join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
2.可以想象成插队
例题：测试Join线程
package come.state;
//测试Join线程
public class TestJoin implements Runnable {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("vip来了"+i);
}
}
public static void main(String[] args) throws InterruptedException{
//启动线程
TestJoin testJoin =new TestJoin();
Thread thread =new Thread();
thread.start();
//主线程
for (int i = 0; i < 500; i++) {
if (i==200){
thread.join();
}
System.out.println("main"+i);
}
}
}
线程礼让状态观测
线程可以处于以下状态之一
1.NEW ： 尚未启动的线程处于此状态.
2.RUNNABLE : 在Java虚拟机中执行的线程处于此状态。
3.BLOCKED : 被阻塞等待监视器锁定的线程处于此状态。
4.WAITING： 正在等待另一个线程执行特定动作的线程处于此状态
5.TIMED_WAITING：正在等待另一个线程执行动作到达指定等待时间的线程处于此状态。
6.TERMINATEO : 已经退出的线程处于此状态。
例题
package come.state;
public class TestState {
//观察测试线程状态
public static void main(String[] args) {
Thread thread =new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("///////");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);//NEW
//观察启动后
thread.start();
state = thread.getState();
System.out.println(state);//RUN
while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
state =thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
线程的优先级
1. Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度那个线程来执行。
2.线程的优先级用数字表示，范围从1~10
。Thread.MIN_PRIORITY = 1;
。 Thread.MAX_PRIORITY = 10;
。 Thread.NORM_PRIORITY = 5;
3.使用以下方式改变或取优先级
。 getPriority().setPriority(int XXX) [优先级的设定建议在start()调度前]
注意：
优先级低的只是意味着获得调度的概率低，并不是优先级低的就不会被调用了，这都是看CPU的调度
例题：测试线程的优先级
package come.state;
//测试线程有先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority =new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
Thread t5 = new Thread(myPriority);
Thread t6 = new Thread(myPriority);
//设置优先级,在启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护线程
- 线程分为用户线程和守护线程
- 虚拟机必需确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如：后台记录操作日志，监控内存，垃圾回收等
例题：测试守护线程
package come.state;
//测试守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认false 表示用户线程，正常的线程都是用户用户线程。。。
thread.start();//上帝守护你线程启动
new Thread(you).start();//你 用户线程启动
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("一生都开心");
}
System.out.println("====goodbye world!=====");
}
}
.
NEW
原文地址：http://www.cnblogs.com/SXDMG/p/16865966.html
1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！
2. 分享目的仅供大家学习和交流，请务用于商业用途!
3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！
4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！
5. 如有链接无法下载、失效或广告，请联系管理员处理！
6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！
7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！
8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载
声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性
