Java多线程编程（线程的常用操作）

Java多线程开发线程的常用操作

线程常用操作

线程的命名和取得

线程的命名和取得都是来源于Thread类中线程名称的操作

常用有一下三种操作

• 构造方法命名：public Thread(Runnalbe target,String name) ;
• setName()方法命名：public final void setName(String name);
• getName()方法取得名字：public final String getName();范例:在run（）方法中获取线程名称

class mythread implementsRunable{@Overridepublicvoid run{System.out.println(Thrad.currentThread().getName());}}publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{
         mythread mt=newmythread();newThread(mt,"线程A").start();//设置了线程名字newThread(mt).start();//未设置线程名字newThread(mt,"线程B").start();//设置了线程名字           }}

获取线程名称时，未命名线程会自动分配名称
接下来获取主线程名称

class mythread implementsRunable{@Overridepublicvoid run{System.out.println(Thrad.currentThread().getName());}}publicclassThreadDemo{publicstaticvoidmain(String[] args) throAws Exception{
         mythread mt=newmythread();newThread(mt,"线程对象").start();//设置了线程名字                       
        mt.run();//对象直接调用run()方法}}

获取主线程名称为main（主方法也是线程）

线程休眠

我们可以希望某个线程能够暂缓执行以方便观察运行状态

在进行休眠的时候有可能会产生在进行休眠的时候有可能会产生
中断异常“InterruptedException”，中断异常属于Exception的子类，证明该异常必须进行处理

休眠方法:

• 休眠：public static void sleep(long millis) throws InterruptedException;
• 休眠：public static void sleep(long mills,int nanos) throws InterruptedException;

范例:观察休眠处理（单个对象进行线程休眠处理）

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{newThread(()->{for(int x=0;x<10;x++){System.out.println(Thread.currentThrad().getName()+",x="+x);try{Thread.sleep(1000);暂缓执行               
               }catch(InterruptedException e){
                   e.printStackTrace();}}},"线程对象").start();}}

在线程的启动上有线程后，当程序休眠再启动也有先后，就像接力比赛，接棒时当作休眠，休眠后每个人的运行速度是不相同的，这就造成了线程执行完毕的先后顺序也是不同的

范例：产生多个线程对象进行线程处理

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Runnable run=()->{for(int x=0;x<10;x++){System.out.println(Thread.currentThrad().getName()+",x="+x);try{Thread.sleep(1000);暂缓执行               
               }catch(InterruptedException e){
                   e.printStackTrace();}}};for(int num=0;num<5;num++){newThread(run,"执行线程"+num).start();}}}

线程休眠要通过运行代码自己观察

线程中断

在之前的线程休眠中发现里面提供有一个中断异常，这实际上证明线程休眠是可以被打断的，这种打断肯定是由其他线程完成的

在Thread类里面提供有线程处理方法

• 判断线程是否被中断：public boolean isInterrupted()；
• 中断线程执行：public void interrupt();范例：观察线程的中断处理

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Thread thread=newThread(()->{System.out.println("*****我需要休眠*****");try{Thread.sleep(10000);//休息10秒System.out.println("***睡足了，可以去工作了***");}catch(InterruptedException e){// TODO Auto-generated catch blockSystem.out.println("休息被打断");}}); 
        thread.start();//开始休息Thread.sleep(1000);//先休息1秒钟if(!thread.isInterrupted()){//询问是否中断休息    //没有中断
            thread.interrupt();//现在打断你的休息}}}

正在执行的线程都是可以被中断的，中断的线程必须进行异常处理

线程强制运行

当满足某些条件之后，某一个线程对象可以一直独占资源一直到线程结束

范例:观察一个没有强制执行的程序

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Thread thread=newThread(()->{for(int x=0;x<100;x++){try{Thread.sleep(100);}catch(InterruptedException e){// TODO Auto-generated catch block
                    e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"执行、x="+x);}},"玩耍的线程"); 
        thread.start();for(int x=0;x<100;x++){Thread.sleep(100);System.out.println("霸道的main线程执行x="+x);}}}

我们发现在子线程会和主线程抢占资源进行输出，接下来我们看看在利用了线程的强制执行后的运行状态

在Thread类里面提供有强制执行方法，join()方法

public final void join() throws InterruptedException

利用join（）方法我们可以使线程强制执行独占资源

从强制执行抛出异常看出，强制执行也可以被中断

范例：强制执行程序

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Thread mainThread=newThread().currentThread();//获取主线程Thread thread=newThread(()->{for(int x=0;x<100;x++){try{Thread.sleep(100);}catch(InterruptedException e){// TODO Auto-generated catch block
                    e.printStackTrace();}if(x>3){try{
                        mainThread.join();//霸道的线程开始执行}catch(InterruptedException e){// TODO Auto-generated catch block
                        e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+"执行、x="+x);}},"玩耍的线程"); 
        thread.start();for(int x=0;x<100;x++){Thread.sleep(100);System.out.println("霸道的main线程执行x="+x);}}}

可以看出当下x>3后main（）开始独占资源，当main（）执行完成后其他线程才开始执行

在进行强制执行的时候一定要获取强制执行线程对象才可以进行join的操作

线程礼让

在多线程中，可以先将资源让出去让别的线程先执行，线程的礼让可以用Thread中的方法

• 礼让方法：public static void yield();

范例:线程的礼让执行

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Thread thread=newThread(()->{for(int x=0;x<100;x++){if(x%3==0){Thread.yield();//玩耍的线程礼让了System.out.println("****玩耍的线程礼让了*****");}try{Thread.sleep(100);}catch(InterruptedException e){// TODO Auto-generated catch block
                    e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"执行、x="+x);}},"玩耍的线程"); 
        thread.start();for(int x=0;x<100;x++){Thread.sleep(100);System.out.println("霸道的main线程执行x="+x);}}}

每一次调用yield（）都只会礼让一次当前的资源

线程优先级

从理论上讲线程的优先级越高越有可能先执行（越有可能先抢占到资源）在Thread类里面提供有如下的两个处理方法

• 设置优先级：public final void setPriority(int newPriority);
• 获取优先级：public final int getPriority(); 在进行优先级定义的时候都是通过int型的数字来进行完成的，而对于此类数字的选择在Thread类里面就有定义
• 最高优先级：public static final int MAX_PRIORITY、10（优先级的值）
• 中等优先级：public static final int NORM_PRIORITY、5（优先级的值）
• 最低优先级：public static final int MIN_PRIORITY、1（优先级的值）

范例：没有设置优先级

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Runnable run=()->{for(int x=0;x<10;x++){try{Thread.sleep(1000);}catch(InterruptedException e){// TODO Auto-generated catch block
                    e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"执行");}};Thread threadA=newThread(run,"线程A对象");Thread threadB=newThread(run,"线程B对象");Thread threadC=newThread(run,"线程C对象");
        threadA.start();
        threadB.start();
        threadC.start();}}

不同电脑效果不同，本人的是B优先执行
接下来看使用优先级后电脑执行的效果
范例:观察设置优先级后的效果

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{Runnable run=()->{for(int x=0;x<10;x++){try{Thread.sleep(1000);}catch(InterruptedException e){// TODO Auto-generated catch block
                    e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"执行");}};Thread threadA=newThread(run,"线程A对象");Thread threadB=newThread(run,"线程B对象");Thread threadC=newThread(run,"线程C对象");
        threadA.setPriority(Thread.MIN_PRIORITY);//把AB设置优先级最小
        threadB.setPriority(Thread.MIN_PRIORITY);//把AB设置优先级最小
        threadC.setPriority(Thread.MAX_PRIORITY);//把AB设置优先级最小
        threadA.start();
        threadB.start();
        threadC.start();}}

提高有先级确实可以提高线程先执行的可能，但是并不是绝对先执行

补充：主方法是一个主线程，主线程的优先级是多少呢？

publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{System.out.println(Thread.currentThread().getPriority());}}

发现主线程的优先级是5，只是中等优先级，同时这与我们默认的方法的优先级是相同的