Java高并发-多线程基础

1.多线程基础

中断线程

public void Thread.interrupt() //中断线程

public boolean Thread.isInterrupted() //判断是否被中断

public static boolean Thread.interrupted() //判断是否被中断，并清除当前中断中断

线程的基本操作

中断线程

public void run(){

         while(true){

                   Thread.yeild();

         }

}

t1.interrupt();

public void run(){

         while(true){

                   if(Thread.currentThread().isInterrupted()){

                            System.out.println("Interruted!");

                            break;

                   }

                   Thread.yield();

         }

}

Java线程中的Thread.yield( )方法，译为线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，

让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。

    yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

线程的基本操作--线程中断

public static native void sleep(long mills) throws InterruptedException

public void run(){

         while(true){

                   if(Thread.currentThread().isInterrupted()){

                            System.out.println("Interrupted!");

                            break;

                   }

                   try {

                            Thread.sleep(2000);

                   } catch (InterruptedException e){

                            System.out.println("Interrupted When Sleep");

                            //设置中断状态，抛出异常后会清除中断标记位

                            Thread.currentThread().interrupt();

                   }

                   Thread.yield();

         }

}

挂起（suspend）和继续执行（resume）线程

-  suspend()不会释放锁

-  如果加锁发生在resume()之前，则死锁发生

stop()、suspend()和resume()方法不推荐使用

 

等待线程结束（join）和谦让（yeild）

public final void join() throws InterruptedException

public final synchronized void join(long millis) throws InterruptedException

public class JoinMain {

         public volatile static int i = 0;

         public static class AddThread extends Thread {

                   @Override

                   public void run(){

                            for(i = 0; i < 10000000; i++);

                   }

         }

         public static void main(String[] args) throws InterruptedException {

                   AddThread at = new AddThread();

                   at.start();

                   at.join();

                   System.out.println(i);

         }

}

join的本质                         线程执行完毕后

while(isAlive()){                  系统会调用

         wait(0);                      notifyAll()

}

不要在Thread实例上使用wait()和notify()方法

守护线程

在后台默默地完成一些系统性的服务，比如垃圾回收线程、JIT线程就可以理解为守护线程

当一个Java应用内，只有守护线程时，Java虚拟机就会自然退出

Thread t = new DaemonT();

t.setDaemon(true);

t.start();

线程优先级

高优先级的线程更容易在竞争中获胜

基本的线程同步操作

synchronized

- 指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

- 直接作用于实例方法：相当于对当前实力加锁，进入同步代码前要获得当前实例的锁。

-直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

Object.wait() Object.notify()

会释放锁

指定加锁对象

public void run(){

         FOR(int j = 0; j < 100000000; j+++){

                   synchronized(instance){

                            i++;

                   }

         }

}

实例方法同步

public synchronized void increase(){

         i++;

}

静态方法同步

public static synchronized void increase(){

         i++;

}

参考《实战Java高并发程序设计》