java多线程使用sleep后线程停止不再执行

环境:jdk1.7
程序代码:
启动线程:

 import java.text.SimpleDateFormat;
import java.util.Date;

public class CTThread implements Runnable{

    @Override
    public void run() {
        Thread upds = new Thread(new UpdateDSThread());
        Thread uphs = new Thread(new UpdateHSThread());
        uphs.setPriority(7);
        Thread dh = new Thread(new DeleteHistory());
        Thread check = new Thread(new CheckStatus());
        Thread cp = new Thread(new CheckPool());
//        Thread sc = new Thread(new SCThread());

        upds.start();
        uphs.start();
        dh.start();
        check.start();
        cp.start();
//        sc.start();
        SimpleDateFormat dd = new SimpleDateFormat("yyyy-MM-dd: HH:mm:ss");
        while(true){
            System.out.println("线程检查~~~·"+dd.format(new Date()));
            System.out.println("upds:"+upds.getState()+upds.getPriority());
            System.out.println("check:"+check.getState()+check.getPriority());
            System.out.println("uphs:"+uphs.getState()+uphs.getPriority());
            System.out.println("dh:"+dh.getState()+dh.getPriority());
            System.out.println("cp:"+cp.getState()+cp.getPriority());
//            System.out.println("sc:"+sc.isAlive()+sc.getPriority());
            if(!upds.isAlive()){
                upds = new Thread(new UpdateDSThread());
                upds.start();
            }
            if(!check.isAlive()){
                check = new Thread(new CheckStatus());
                check.start();
            }
            if(!uphs.isAlive()){
                uphs = new Thread(new UpdateHSThread());
                uphs.start();
            }
            if(!dh.isAlive()){
                dh = new Thread(new DeleteHistory());
                dh.start();
            }
            if(!cp.isAlive()){
                cp = new Thread(new CheckPool());
                cp.start();
            }
//            if(!sc.isAlive()){
//                sc = new Thread(new SCThread());
//                sc.start();
//            }
            try {
                Thread.sleep(1000*13);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

线程1:

 import entity.Device;
import hibernate.Search;
import main.UpdateDeviceStatus;

import java.util.Iterator;
import java.util.List;

public class UpdateHSThread implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("iops线程");
        while(true){
            Device device;
            UpdateDeviceStatus update = new UpdateDeviceStatus();
            Search search = new Search();
            List devicelist = search.getALL("Device");
            Iterator deviceitor = devicelist.iterator();
            long startTime = System.currentTimeMillis();
            try {
                System.out.println("iops设备数量:" + devicelist.size());
                while (deviceitor.hasNext()) {
                    device = (Device) deviceitor.next();
                    System.out.println("HS连接设备:" + device.getIp());
                    System.out.println("HSstart");
                    update.updateHS(device.getFlag(),device.getcinfo());
                    System.out.println("HSover");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
            }
            long endTime = System.currentTimeMillis();
            try {
                long time = endTime - startTime;
                    Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

线程2:

 import entity.Device;
import hibernate.Search;
import main.UpdateDeviceStatus;

import java.util.Iterator;
import java.util.List;

public class UpdateDSThread implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            System.out.println("DS进程~~~~~");
            Device device = new Device();
            UpdateDeviceStatus update = new UpdateDeviceStatus();
            Search search = new Search();
            List devicelist = search.getALL("Device");
            Iterator deviceitor = devicelist.iterator();
            while (deviceitor.hasNext()) {
                device = (Device) deviceitor.next();
                try {
                    System.out.println("DS连接设备" + device.getIp());
                    System.out.println("DSstart");
                    update.updateDS(device.getFlag(),device.getcinfo());
                    System.out.println("DSover");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                }
            }
            try {
                Thread.sleep(1000 * 60);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

一共有两个类似的线程,程序刚刚启动的时候一切正常,但是当过一段时间后会有一个线程不再进行循环,用Thread.getState()查询的线程状态是TIMED_WAITING。
没有异常输出,重启程序后一切正常,两个线程都会每隔规定时间循环一次,但是经过一段时间后又会变成只有一个线程正常循环,另一个停在那。从程序启动到出问题的时间不固定,有的时候一周才出一次,有的时候一小时内就会出。
查不出来是什么问题,求大神解答,挺急的

 线程检查~~~·2017-12-13: 17:19:05
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
iops设备数量:4
HS连接设备:null
HSstart
HSover
HS连接设备:172.10.4.101
HSstart
connect 172.10.4.101 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
清理历史记录
171213171915
171212171915
startdelete
10
deleteover
dh over~~~
线程检查~~~·2017-12-13: 17:19:18
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
iops设备数量:4
HS连接设备:null
HSstart
HSover
HS连接设备:172.10.4.101
HSstart
connect 172.10.4.101 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
线程检查~~~·2017-12-13: 17:19:31
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
iops设备数量:4
HS连接设备:null
HSstart
HSover
HS连接设备:172.10.4.101
HSstart
connect 172.10.4.101 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
HS连接设备:172.10.4.200
HSstart
connect 172.10.4.200 success
实时iops
写入iops
HSover
检查池容量
iops设备数量:4
HS连接设备:null
HSstart
HSover
HS连接设备:172.10.4.101
HSstart
connect 172.10.4.101 success
实时iops
线程检查~~~·2017-12-13: 17:19:44
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
线程检查~~~·2017-12-13: 17:19:57
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
DS进程~~~~~
DS连接设备null
DSstart
DSover
DS连接设备172.10.4.101
DSstart
systeminfo
connect 172.10.4.101 success
存储池容量
connect 172.10.4.101 success
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
DSover
清理历史记录
171213172002
171212172002
startdelete
8
deleteover
dh over~~~
线程检查~~~·2017-12-13: 17:20:10
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
线程检查~~~·2017-12-13: 17:20:23
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
检查池容量
线程检查~~~·2017-12-13: 17:20:36
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
设备检查
CS连接设备172.10.4.101
connect 172.10.4.101 success
nodecanister
canistersinfo
online
online
online
online
drivesinfo
psusinfo
batteriesinfo
CS连接设备172.10.4.200
connect 172.10.4.200 success
nodecanister
canistersinfo
online
null
drivesinfo
CS连接设备172.10.4.200
connect 172.10.4.200 success
nodecanister
canistersinfo
online
null
drivesinfo
清理历史记录
171213172049
171212172049
startdelete
10
deleteover
dh over~~~
线程检查~~~·2017-12-13: 17:20:49
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
DS进程~~~~~
DS连接设备null
DSstart
DSover
DS连接设备172.10.4.101
DSstart
systeminfo
connect 172.10.4.101 success
存储池容量
connect 172.10.4.101 success
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
线程检查~~~·2017-12-13: 17:21:02
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
DSover
线程检查~~~·2017-12-13: 17:21:15
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
线程检查~~~·2017-12-13: 17:21:28
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
检查池容量
清理历史记录
171213172136
171212172136
startdelete
8
deleteover
dh over~~~
线程检查~~~·2017-12-13: 17:21:41
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
线程检查~~~·2017-12-13: 17:21:54
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5
DS进程~~~~~
DS连接设备null
DSstart
DSover
DS连接设备172.10.4.101
DSstart
systeminfo
connect 172.10.4.101 success
存储池容量
connect 172.10.4.101 success
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
DSover
DS连接设备172.10.4.200
DSstart
systeminfo
connect 172.10.4.200 success
存储池容量
connect 172.10.4.200 success
DSover
线程检查~~~·2017-12-13: 17:22:07
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5

上面是我自己程序中的输出,可以看到刚开始DS和HS两个线程是循环运行的,但是到后面就只有DS了

而且两个线程不一定哪个会停,但是肯定会停一个

其余的线程不会出问题,只有这两个标出来的线程会随机的停一个,很玄学

Thread.sleep() 是在指定的毫秒数内让_**当前**_正在执行的线程休眠, 不清楚你的调用是怎么写的

有没有停住的log看看

最好不要用优先级来管理线程调度,在只有几个线程的竞争中,如果你的电脑cpu是多核,优先级起不到明显的作用。还有请问你两个线程有没有存在资源竞争?

你的主线程里检测到线程不是isAlive()就新开一个线程,isAlive()检测的是线程处于运行或者开始准备运行状态
而你程序中很多的线程调用sleep()后处于TIMED_WAITING状态,开启线程数量太多的时候,JVM频繁引发GC,然后占用大量CPU,导致挂起
你可以看看cpu的情况

是否是因为调用的函数里有线程等待互斥等 不允许多线程同时访问的操作?

应该是线程在这个方法里阻塞了 update.updateHS(device.getFlag(),device.getcinfo());

update.updateDS(device.getFlag(),device.getcinfo());,你好好看看这两个方法

                                    System.out.println("HSstart");
                update.updateHS(device.getFlag(),device.getcinfo());
                System.out.println("HSover");

看log能看到 该线程打印"HSstart" 后进入方法,"HSover"没有被打印

你有没有发现,每次都是TIMED_WAITINGS
线程检查~~~·2017-12-13: 17:19:57
upds:TIMED_WAITING5
check:TIMED_WAITING5
uphs:TIMED_WAITING7
dh:TIMED_WAITING5
cp:TIMED_WAITING5

有没有存在线程死锁呢?一个线程里面运行两个线程UpdateDSThread 线程进来,运行到等待(1000 * 60) 第二次循环又进UpdateDSThread
线程又在等待 (1000 * 60)而你CTThread 线程的等待时间(1000 * 13),如果没有出现别的意外,是线程死锁了

举个例子:我的线程都是这么干的:
Runnable run1=new UpdateHSThread();
Thread thread1=new Thread(run1);
thread1.setProxy(5);//设置优先级
thread1.setName("UpdateHSThread");
thread1.start();

所有的线程的优先级都是5,这很重要

估计你是想要这些线程按照一定次序执行 控制线程执行顺序不能用优先级和sleep

每次检查都是timed_waiting 可能跟你sleep的时间太长有关,
要控制线程测序可以考虑 volatile标记 Executor单线程池,搞了那么多线程?建议你重新梳理业务逻辑 再进行代码结构设计

哥们挑重点把问题挑出来,这样优点尴尬

是不是其他线程调用退出该线程的操作了,你这个现场睡眠,其他线程执行完就退出了。

楼主的问题解决了嘛,我也遇到了同样的问题,线程调度每次都是不执行,但重启后就可以正常一段时间