这篇博客主要是总结一下Java中线程常用的操作方法。
Thread(Runnable target)
分配一个新的Thread对象
Thread(Runnable target,String name)
分配新的Thread对象,并给线程命名
Thread(String name)
分配新的Thread对象
static Thread currentThread()
返回当前正在执行的线对象的引用
long getId()
返回线程的标识符
String getName()
返回线程的名称
void setName(String name)
改变线程名称,使之与参数name相同
boolean isAlive()
测试线程是否处于活动状态
Demo:
public class ThreadDemo {
public static void main(String args[])
{
MyThread myThread=new MyThread();
//实例化一个线程对象并给其赋值
Thread thread=new Thread(myThread,"小白线程");
//获取线程的ID
System.out.println(thread.getId());
//设置线程的名称
thread.setName("小黑线程");
thread.start();
System.out.println("thread线程是否活动"+thread.isAlive());
}
}
class MyThread implements Runnable
{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
static void sleep(long millis)
休眠指定的毫秒继续执行
sleep方法休眠完成后,线程会重新恢复到就绪状态
sleep方法的原理
让当前线程进入休眠状态,让出当次执行的CPU时间,但是不丢失监视器的所属权。
static void sleep(long millis,int nanos)
休眠指定毫秒 纳秒之后继续执行
Demo:
public class ThreadDemo2 {
public static void main(String args[])
{
MyThread2 myThread2=new MyThread2();
Thread thread=new Thread(myThread2);
thread.start();
for(int i=0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()
+"-"+i+" ");
//让当前线程进入休眠状态
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
class MyThread2 implements Runnable
{
@Override
public void run() {
for (int i=0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()
+"-"+i);
try {
//让当前线程进入休眠状态
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
void join()
等待调用该方法的线程执行完毕之后,再去执行其他线程
void join(long millis)
等待该线程终止的时间最长为milli毫秒
void join(long millis,int nanos)
等待该线程的终止的时间最长毫秒 纳秒
Demo:
public class ThreadDemo3 {
public static void main(String args[])
{
MyThread3 myThread3=new MyThread3();
Thread thread=new Thread(myThread3);
thread.start();
for (int i=0;i<9;i++)
{
System.out.println("Main"+i);
if(i==5)
{
try {
//等待thread线程终止在执行主线程
thread.join();
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
class MyThread3 implements Runnable{
@Override
public void run() {
for(int i=0;i<8;i++)
{
System.out.println(Thread.currentThread().getName()+"-"+i);
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
void interrupt()
中断线程
static boolean interrupted()
测试当前线程是否已经中断
void setPriority(int newPriority)
更改线程的优先级
优先级高的线程也不一定百分百抢到CPU,只是说抢到的概率大一些
static int MAX_PRIORITY
线程可以具有的最高优先级
static int MIN_PRIORITY
线程可以具有的最低优先级
static int NORM_PRIORITY
分配给线程的默认优先级
Demo:
/**
* 中断线程
* 1.Interrupt()方法只是设置了线程的中断标记为true,并没有真正的中断线程,线程还在执行
* 真正中断线程还是得自身中断
* 2.自定义标记完成中中断
*/
/**
* 设置线程的优先级
*/
public class ThreadDemo4 {
public static void main(String args[])
{
MyThread4 myThread4=new MyThread4();
Thread thread=new Thread(myThread4,"t1");
//start方法是开辟新的线程执行run()方法
Mythread5 mythread5=new Mythread5();
Thread thread1=new Thread(mythread5,"t2");
//设置线程的优先级
thread.setPriority(Thread.MAX_PRIORITY);
thread1.setPriority(Thread.MIN_PRIORITY);
thread.start();
thread1.start();
for (int i=0;i<7;i++)
{
System.out.println("Main-"+i);
if(i==5)
{
//thread.interrupt();//设置中断标记(中断状态为True)
mythread5.setFlag(false);//中断线程
}
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
class MyThread4 implements Runnable
{
@Override
public void run() {
for (int i=0;i<7;i++)
{
System.out.println(Thread.currentThread().getName()+i);
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
class Mythread5 implements Runnable{
private boolean flag = true;
public boolean isFlag()
{
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
int i=0;
while (flag)
{
System.out.println(Thread.currentThread().getName()+i);
i++;
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
线程可以分为用户线程与守护线程,我们自己创建的线程一般为用户线程,守护线程是指当程序中没有用户线程的时候,所有的守护线程都会终止,如GC 垃圾回收机制
boolean isDaemon()
测试该线程的是否为守护线程
void setDaemon(boolean on)
将该线程标记为守护线程或者用户线程
static void yield()
暂停当前正在执行的线程对象,并执行其他线程让出本次的执行权,只让一次
public class ThreadDemo5 {
public static void main(String args[])
{
MyThread6 myThread6=new MyThread6();
Thread thread=new Thread(myThread6);
//设置线程为守护线程
// thread.setDaemon(true);
thread.start();
for(int i=0;i<10;i++)
{
System.out.println("Main-"+i);
if(i==5)
{
//让出当次的cpu的执行时间
Thread.yield();
}
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}
class MyThread6 implements Runnable{
@Override
public void run() {
for (int i=0;i<20;i++)
{
System.out.println("Mythread6-"+i);
try {
Thread.sleep(1000);
}catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
}