java 多线程

java的多线程

Posted by BY annie dong on March 27, 2018

学习java道阻且长，基础也很重要，不求快，但求稳

什么是线程

线程

进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

多线程

在单个程序中可以同时运行多个不同的线程执行不同的任务。多线程编程的目的，就是“最大限度地利用cpu资源”，当某一线程的处理不需要占用cpu而只和io等资源打交道时，让需要占用Cpu的其他线程有其他机会获得cpu资源。从根本上说，这就是多线程编程的最终目的。

java建立简单多线程

thread类

import java.util.*;
class TimePrinter extends Thread {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }
    @overwrite
    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new 
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }
    static public void main(String args[]) {
        TimePrinter tp1 = new TimePrinter(1000, "Fast Guy");
        tp1.start();   // Thread 的 start() 函数，调用 run()，来启动线程
        TimePrinter tp2 = new TimePrinter(3000, "Slow Guy");
        tp2.start();
     
    }
}

Runnable 接口

import java.util.*;
class TimePrinter implements Runnable {
    int pauseTime;
    String name;
    public TimePrinter(int x, String n) {
        pauseTime = x;
        name = n;
    }
    public void run() {
        while(true) {
            try {
                System.out.println(name + ":" + new 
                    Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            } catch(Exception e) {
                System.out.println(e);
            }
        }
    }
    static public void main(String args[]) {
        Thread t1 = new Thread (new TimePrinter(1000, "Fast Guy")); //用Runnable是需要new Thread
        t1.start();
        Thread t2 = new Thread (new TimePrinter(3000, "Slow Guy"));
        t2.start();
     
    }
}

推荐使用Runnable，由于JAVA是单继承，使用接口扩展更好

synchronized 关键字

public class Account {
    String holderName;
    float amount;
    public Account(String name, float amt) {
        holderName = name;
        amount = amt;
    }
    public 
        synchronized void deposit(float amt) {
        amount += amt;
    }
    public 
        synchronized void withdraw(float amt) {
        amount -= amt;
    }
    public float checkBalance() {
        return amount;
    }
}

deposit() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理

class CopyMachine {
     
   public synchronized void makeCopies(Document d, int nCopies) {
      //only one thread executes this at a time
   }
     
   public void loadPaper() {
      //multiple threads could access this at once!
     
      synchronized(this) {
         //only one thread accesses this at a time
         //feel free to use shared resources, overwrite members, etc.
      }
   }
}

synchronized可以在任一时刻对于给定的类的实例，方法或代码块加锁，然后他们只能被一个线程执行

  • synchronized 实例 -> 每个实例，一个线程可以访问该实例
  • synchronized 实例方法 -> 每个对象，只有一个线程可以执行该方法
  • synchronized 静态方法 -> 每个类，只有一个线程可以执行该方法

volatile 关键字

  • 可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
  • 原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。
    从实践角度而言，volatile的一个重要作用就是和CAS结合，保证了原子性，详细的可以参见java.util.concurrent.atomic包下的类，比如AtomicInteger。
    volatile vs synchronized

    volatile可以修饰属性，只是让属性对所有线程可见，每次读取都是最新的值, 具体事例下面两段代码等价:

    class VolatileFeaturesExample {
  volatile long vl = 0L;  //使用volatile声明64位的long型变量
  public void set(long l) {
      vl = l;   //单个volatile变量的写
  }
  public void getAndIncrement () {
      vl++;    //复合（多个）volatile变量的读/写
  }
  public long get() {
      return vl;   //单个volatile变量的读
  }
}

class VolatileFeaturesExample {
    long vl = 0L;               // 64位的long型普通变量
    public synchronized void set(long l) {     //对单个的普通 变量的写用同一个监视器同步
        vl = l;
    }
    public void getAndIncrement () { //普通方法调用
        long temp = get();           //调用已同步的读方法
        temp += 1L;                  //普通写操作
        set(temp);                   //调用已同步的写方法
    }
    public synchronized long get() { 
    //对单个的普通变量的读用同一个监视器同步
        return vl;
    }
}

java高级多线程

线程的状态 ThreadStatus

  • STATE_NEW a thread have not yet started in a state
  • STATE_RUNNABLE a thread excueting in jvm is in this state
  • STATE_SLEEPING a thread is sleeping
  • STATE_IN_OBJECT_WAIT a thread is waiting for another thread preform a action in a state
  • STATE_IN_OBJECT_WAIT_TIMED a thread is waiting for another thread preform a action in a specified waiting time in a state
  • STATE_PARKED
  • STATE_PARKED_TIMED
  • STATE_BLOCKED_ON_MONITOR_ENTER a thread is blocked waiting for a monitor lock in the state
  • STATE_TERMINATED a thread have existed in the state

线程间通信

wait()

当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止，调用 wait() 方法使处理器放弃它当前拥有的对象的锁。如果对象在方法级别上使同步的，这种方法能够很好的工作，因为它仅仅使用了一个锁。如果它使用 fine-grained 锁，则 wait() 将无法放弃这些锁。此外，一个因为调用 wait() 方法而阻塞的线程，只有当其他线程调用 notifyAll() 时才会被唤醒。
必须在synchronized中使用

notify() & notifyAll()

只通知一个正在等待的线程，当对每次只能由一个线程使用的资源进行访问限制时，不可能预知哪个线程会获得这个通知，因为这取决于 Java 虚拟机 (JVM) 调度算法。 必须在synchronized中使用

yield()

将 CPU 让给另一个线程，当线程放弃某个稀有的资源（如数据库连接或网络端口）时，它可能调用 yield() 函数临时降低自己的优先级，以便某个其他线程能够运行
如果线程正拥有一个锁（因为它在一个同步方法或代码块中），则当它调用 yield() 时不能够释放这个锁。这就意味着即使这个线程已经被挂起，等待这个锁释放的其他线程依然不能继续运行。为了缓解这个问题，最好不在同步方法中调用 yield 方法

join()

当前线程进入waiting状态，等待join的线程执行完成

守护线程

有两类线程：用户线程和守护线程。 用户线程是那些完成有用工作的线程。 守护线程 是那些仅提供辅助功能的线程。Thread 类提供了 setDaemon() 函数。Java 程序将运行到所有用户线程终止，然后它将破坏所有的守护线程。在 Java 虚拟机 (JVM) 中，即使在 main 结束以后，如果另一个用户线程仍在运行，则程序仍然可以继续运行。

线程优先级

Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。但是，该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统策略。在某些情况下，优先级相同的线程分时运行；在另一些情况下，线程将一直运行到结束。请记住，Java 支持 10 个优先级，基层操作系统支持的优先级可能要少得多，这样会造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来让其他线程run。通常情况下，请不要依靠线程优先级来控制线程的状态。

多线程的各种异常情况

死锁

当一个线程需要一个资源而另一个线程持有该资源的锁时，就会发生死锁。这种情况通常很难检测。但是，解决方案却相当好：在所有的线程中按相同的次序获取所有资源锁。例如，如果有四个资源 ―A、B、C 和 D ― 并且一个线程可能要获取四个资源中任何一个资源的锁，则请确保在获取对 B 的锁之前首先获取对 A 的锁，依此类推。如果“线程 1”希望获取对 B 和 C 的锁，而“线程 2”获取了 A、C 和 D 的锁，则这一技术可能导致阻塞，但它永远不会在这四个锁上造成死锁。

class Broken 
{   Object lock1 = new Object(); 
   Object lock2 = new Object(); 
   void a() 
   {   synchronized( lock1 ) 
       {   synchronized( lock2 ) 
           {   // do something 
           } 
       } 
   } 
   void b() 
   {   synchronized( lock2 ) 
       {   synchronized( lock1 ) 
           {   // do something 
           } 
       } 
   }
  1. 调用 yield() 方法能够将当前的线程从处理器中移出到准备就绪队列中。
  2. 另一个方法则是调用 sleep() 方法，使线程放弃处理器，并且在 sleep 方法中指定的时间间隔内睡眠。
  3. 另外一个解决方法则是调用 wait() 方法，使处理器放弃它当前拥有的对象的锁。

    活锁

    当一个线程忙于接受新任务以致它永远没有机会完成任何任务时，就会发生活锁。这个线程最终将超出缓冲区并导致程序崩溃。试想一个秘书需要录入一封信，但她一直在忙于接电话，所以这封信永远不会被录入。

    内存损坏

    如果明智地使用 synchronized 关键字，则完全可以避免内存错误这种气死人的问题。

    资源耗尽

    某些系统资源是有限的，如文件描述符。多线程程序可能耗尽资源，因为每个线程都可能希望有一个这样的资源。如果线程数相当大，或者某个资源的侯选线程数远远超过了可用的资源数，则最好使用 资源池。一个最好的示例是数据库连接池。只要线程需要使用一个数据库连接，它就从池中取出一个，使用以后再将它返回池中。资源池也称为 资源库。

参考资料

Java 程序中的多线程

CATALOG
    FEATURED TAGS
    sql git git-flow trunk-based OAuth OAuth2 javascript arithmetic http https redis redis集群 english email tcp socket 集群 持久化 java spring annotation 多线程 数据库连接池 Druid spring-boot debug maven gradle druid 强类型 弱类型 functional programming react Java集合 consul 微服务 vagrant credential-osxkeychain two-factor authentication kotlin
    FRIENDS