Java线程的常用操作方法

多线程有很多的方法定义，但是大多数方法都是在Thread类里面的 方法

1.线程的命名和取得

所有的线程的程序的执行每一次都是不同的运行结果，因为会根据自己的情况进行资源抢占，执行的顺序是不同的，那么如果要想区分每一个线程，就必须依靠线程的名字。对于线程的名字，一般而言会在启动之前进行定义，不建议为已经启动的线程更改名称，或者为不同的线程设置重名的情况。
如果要想进行线程名称的操作，可以使用Thread类的如下方法：

public Thread(Runnable target,String name);
//设置名字
public final void setName(String name);
//取得名字
public final String getName();

对于线程名字的操作会出现一个问题，这些方法是属于Thread类的但是如果换回线程类（Runnable子类）并没有继承Thread类，如果要想取得线程的名字，那么我们能够取得的就是当前执行本方法的线程名字。

• 所以在Thread类里面提供有一个方法：取得当前线程对象（public static Thread currentThread()）
  可以直接由Thread类直接调用

//线程操作主类
class MyThread implements Runnable {//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public void run()  {//覆写run方法作为线程的主题操作方法          System.out.println(Thread.currentThread().getName());
        }
}
//此时观察Thread方法类中没有实现Callable的接口
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

如果在实例化Thread对象的时候没有为其设置名字，那么会自动的进行编号命名，也就是保证线程对象的名字不重复

//线程操作主类
class MyThread implements Runnable {//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public void run()  {//覆写run方法作为线程的主题操作方法

            System.out.println(Thread.currentThread().getName());
        }
}
//此时观察Thread方法类中没有实现Callable的接口
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread mt = new MyThread();
        new Thread(mt,"自己的线程A").start();
        new Thread(mt).start();
        new Thread(mt,"自己的线程B").start();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread mt = new MyThread();
        new Thread(mt,"自己的线程A").start();
        mt.run();//直接调用run方法
    }
}

原来主方法就是一个线程，那么所有在主方法上创建的线程实际上都可以将其表示为子线程。
通过以上的代码可以发现线程一直都存在（主方法就是猪线程），可是进程去哪里了？
每当使用java命令去编译一个程序类的时候，对于操作系统而言，都相当于启动了一个新的进程，而main就相当于进程上的一个子线程而已。
提问：每一个JVM程序启动的时候至少启动几个线程？

• main线程：程序的主要执行，以及启动子线程
• gc线程：负责垃圾收集
• 每个JVM启动的时候至少启动2个线程

2.线程的休眠

所谓的线程休眠指的就是让线程的执行速度稍微的变慢一点。

public static void sleep(long millis)throws InterruptedException;
//long声明日期时间、声明文件大小
public static void sleep(long millis,int nanos)throws InterruptedException;

休眠之后会抛出中断异常
范例：观察休眠方式

//线程操作主类
class MyThread implements Runnable  {//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public void run(){//覆写run方法作为线程的主题操作方法
       for(int i =0;i<10000;i++)
       {
           try{
               Thread.sleep(1000);
           }catch (InterruptedException e)
           {
               e.getStackTrace();
           }
           System.out.println(Thread.currentThread().getName()+",x="+i);
       }
    }
}
//此时观察Thread方法类中没有实现Callable的接口
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread mt = new MyThread();
        new Thread(mt,"自己的线程A").start();

    }
}

因为每一次执行到run方法的线程对象都必须进行休眠，所以执行的速度就会变慢。默认情况下，在休眠的时候如果设置了多个线程对象，那么所有的线程对象将一起进入run方法（所谓的一起进入是因为先后顺序太短了，但实际上有区别。）

3.进程优先级

所谓的优先的优先级指的是越高的优先级，越有可能先执行。在Thread类里面有以下两种方法：

• 设置优先级public final void setPriority(int newPriority)
• 取得优先级public final int getPriority()

设置和返回优先级都是使用int类型进行设置

//最小优先级
public static final int MIN_PRIORITY
//中等优先级
public static final int NORM_PRIORITY
//最大优先级
public static final int MAX_PRIORITY

public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread mt = new MyThread();
       Thread t1 = new Thread(mt,"自己的线程对象A");
       Thread t2 = new Thread(mt,"自己的线程对象B");
        Thread t3 = new Thread(mt,"自己的线程对象C");
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

自己的线程对象B,x=0
自己的线程对象C,x=0
自己的线程对象A,x=0
自己的线程对象B,x=1
自己的线程对象A,x=1
自己的线程对象C,x=1
自己的线程对象B,x=2
自己的线程对象A,x=2
自己的线程对象C,x=2
自己的线程对象B,x=3
自己的线程对象C,x=3
自己的线程对象A,x=3
自己的线程对象A,x=4
自己的线程对象C,x=4
自己的线程对象B,x=4

越有可能先执行但是不一定！！！

 public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理     
 System.out.println(Thread.currentThread().getPriority());
    }

返回值为5

See Also那里是可以看数值的！
主线程属于中等优先级

总结

1. Thread.currentThread可以取得当前线程类对象
2. Thread.sleep（）主要是休眠，感觉是一起休眠实际上是有区别的
3. 优先级越高的线程越可能先执行