Java之线程相关应用实现

后台线程

一个进程中只有后台进程运行，该进程将会结束。

新创建的线程默认为前台线程，Java中只要有一个前台线程运行，就不会结束程序，如果只有后台线程运行，程序就会结束，可以在线程对象启动前执行setDaemon(true)语句设置该线程为后台线程。

class Main {public static void main(String[] args) {System.out.println("main()线程是后台线程吗"+Thread.currentThread().isDaemon());DaemonThread daemon=new DaemonThread();Thread thread=new Thread(daemon,"后台线程");System.out.println("Daemons是后台线程吗"+thread.isDaemon());thread.setDaemon(true);//设置为后台线程System.out.println("Daemons是后台线程吗"+thread.isDaemon());thread.start();//模拟主线程main执行int i=0;for(;i<3;i++){System.out.println(i);}}
}class DaemonThread implements Runnable {//模拟分线程执行public void run(){while(true){System.out.println(Thread.currentThread().getName()+"正在运行");}}}

线程的优先级

使用setPriority方法，设置优先级为1到10；数字越大，优先级越高，获得CPU的使用权机会越大。

class Main {public static void main(String[] args) {Thread minPriority =new Thread(new maxpriority(),"优先级较高线程");Thread maxPriority=new Thread(new minpriority(),"优先级较低线程");minPriority.setPriority(Thread.MIN_PRIORITY);//设置优先级为1maxPriority.setPriority(Thread.MAX_PRIORITY);//设置优先级为10//开启两个线程minPriority.start();maxPriority.start();}}
class maxpriority implements Runnable{public void run(){for(int i=0;i<3;i++) {System.out.println(Thread.currentThread().getName() + "正在输出" + i);}}}
class minpriority implements Runnable{public void run(){for(int i=0;i<3;i++) {System.out.println(Thread.currentThread().getName() + "正在输出" + i);}}
}

线程休眠

当前线程暂停运行，进入阻塞状态哦使用sleep()方法。传入参数单位为毫秒。

sleep调用时，只能让当前正在运行的线程休眠，

class Main {public static void main(String[] args) {new Thread(new Sleepthread()).start();//开启新线程for(int i=1;i<=8;i++){try{  if(i==5){Thread.sleep(1000);}System.out.println("主线程正在输出"+i);Thread.sleep(500);}catch(InterruptedException e){e.printStackTrace();}}}}
class Sleepthread implements Runnable{public void run(){for(int i=1;i<=8;i++){if(i==3){try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}System.out.println("Sleep线程正在输出"+i);try{ Thread.sleep(500);}catch(Exception e){e.printStackTrace();}}}
}

主线程在Sleep线程输出3之前连续输出2,3,4；说明此时Sleep线程在输出值3时先休眠了一段时间；

另外，Sleep线程再输出6之前，主线程也连续输出5,6；说明此时Sleep在输出6时休眠了一段时间。

线程插队

class Main {public static void main(String[] args) throws Exception {Thread thread=new Thread(new Joinrunable(),"thread");thread.start();for(int i=1;i<=4;i++){if(i==2){thread.join();//调用join()方法插队实现}System.out.println(Thread.currentThread().getName()+"线程正在输出"+i);}}
}
class Joinrunable implements Runnable{public void run(){for(int i=1;i<=3;i++){System.out.println(Thread.currentThread().getName()+"线程正在输出"+i);}}
}

main()线程和thread线程互相争夺CPU使用权，然后当i=3时候

线程生命周期的六种基本状态

（1）新建状态

创建一个线程对象后，还没有调用start()方法启动之前的状态

（2）可运行状态

就绪状态，调用了start()方法之后进入的状态。

（3）锁阻塞状态

当一个线程想要获取一个对象锁，该aii锁被其他线程持有，该线程进入锁阻塞状态。

（4）无限等待状态

一个线程等待另一个线程执行一个唤醒动作，该线程进入的状态。

（5）计时等待状态

具有指定等待时间的状态，一直保持到超时或被唤醒

（6)被终止状态

终止运行，由于正常退出或者异常没有被捕获而结束。

线程让步

某个特定时间点，线程暂停抢夺CPU，采用yield()方法实现。

class Main {public static void main(String[] args) throws Exception {//新建两个线程Thread th1=new Fieldthread("th1");Thread th2=new Fieldthread("th2");
//开启两个线程th1.start();th2.start();}
}
class Fieldthread extends Thread {public Fieldthread(String name) {super(name);//调用父类带参构造方法}public void run() {for(int i=1;i<4;i++){System.out.println(Thread.currentThread().getName()+"线程输出"+i);if(i==2){System.out.println("线程让步");//线程让步Thread.yield();}}}
}

线程中断

调用两种方法实现：

interrupt()方法和isInterrupted()方法

isInterrupted方法判断中断标志位，如果为真表示中断。

class Main {public static void main(String[] args) throws Exception {Thread thread=new Thread(new Runnable() {public void run() {for (int i = 0; i < 4; i++) {if(i==2){Thread.currentThread().interrupt();System.out.println("线程是否中断"+Thread.currentThread().isInterrupted());}}}});//创建实例对象thread.start();//启动线程}
}

线程同步

class Main {public static void main(String[] args) throws Exception {Salethread salethread = new Salethread();new Thread((salethread),"线程1").start();//创建并启动新线程new Thread((salethread),"线程2").start();//创建并启动新线程new Thread((salethread),"线程3").start();//创建并启动新线程}
}
class Salethread implements  Runnable{private int tickets=10;public void run(){while(tickets>0){try{Thread.sleep(300);}catch(Exception e){e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"卖出票号是 "+tickets--);}}
}

结果的票数中出现了0；之所以这样是因为每个线程都会先调用sleep方法进入休眠一段时间。即假设票数为3时候，线程2先进入while循环，然后调用sleepf方法休眠一段时间，在此期间票数值不变，因为票数只有在最后输出时候才会减少，线程3进入while循环，然后调用sleep()方法休眠一段时间，于此同时然后线程1进入while循环，然后调用sleep（）方法进入休眠，最后三个线程依次结束休眠状态，相继售票，即票数由3变化到0；

所以为了安全起见，使用同步代码块，使得多线程访问处理同一资源时候，任何时刻只能由一个线程访问处理。

将共享资源的代码放在synchronized（lock）关键字修饰的代码块中。

synchronized(lock){

处理共享资源的代码块

}

lock是指锁，即某个线程执行时，其他线程不能执行。

class Main {public static void main(String[] args) throws Exception {Salethread salethread = new Salethread();new Thread((salethread),"线程1").start();//创建并启动新线程new Thread((salethread),"线程2").start();//创建并启动新线程new Thread((salethread),"线程3").start();//创建并启动新线程}
}
class Salethread implements  Runnable{private int tickets=10;Object lock=new Object();//定义锁public void run(){while(tickets>0){synchronized (lock) { try{Thread.sleep(300);}catch(Exception e){e.printStackTrace();}if(tickets>0){ System.out.println(Thread.currentThread().getName()+"卖出票号是 "+tickets--);}else{break;}}}}
}

同步方法