java 多线程

线程与进程：

区别：

1、进程拥有一整套自己的变量，而进程之间可以共享数据。

2、线程属于更轻量级，开销比进程小。

InterruptedException:

若是我们调用线程的中断方法，当程序即将进入或是已经进入阻塞调用的时候，那么这个中断信号应该由InterruptedException捕获并进行重置；当run()方

法程序段中不会出现阻塞操作的时候，这时候中断并不会抛出异常，我们需要通过interrupted()方法进行中断检查和中断标志的重置。另外，知道IO操作

和synchronized上的阻塞不可中断也是必要的。

一般来说中断线程分为三种情况：

(一) ：中断非阻塞线程

(二)：中断阻塞线程

(三)：不可中断线程

https://www.jianshu.com/p/a8abe097d4ed

线程状态：

new 新建状态，还没有调用start方法时；

runnable:可运行状态，处于执行中的状态，可能会在等待资源。

blocked:被阻塞，线程处于阻塞状态，线程在等待进入某一个同步代码块，但未获得锁的状态。

waitting:等待状态。调用了wait\join\park方法后的等待状态；

timed-waitting：计时等待，调用了

         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>

这些方法的等待状态。

terminated:终止状态，线程结束执行。

线程属性：

通过setpriority设置优先级，1-10优先级由低到高。

依赖于操作系统，不要将程序依赖于优先级。

守护线程：

为其余线程提供服务，其余线程都退出后，它就退出了。

未捕获异常：

unCaguthException

同步：

为了解决竞争问题，可以有以下方案：

1、使用Lock类

lock()方法会锁住代码块，其余线程将被阻塞，无法访问。这种方式一定要unlock，否则线程可能永远阻塞。

如果使用锁， 就不能使用带资源的 try 语句。首先， 解锁方法名不是 close。不过， 即使将它重命名， 带资源的 try 语句也无法正常工作。它的首部希望声明一个新变量。但 是如果使用一个锁， 你可能想使用多个线程共享的那个变量（而不是新变量）。

private Lock bankLock = new ReentrantLock0；// ReentrantLock implements the Lock interface

可重入锁》因为线程可以重复地获得已经持有的锁。锁保持一个持有计数（ hold count) 来跟踪对 lock 方法的嵌套调用。线程在每一次调用 lock 都要调用 unlock 来释放锁。 由于这一特性， 被一个锁保护的代码可以调用另一个使用相同的锁的方法。

公平锁、非公平锁：公平锁倾向于选择等待时间最长的线程，但性能较低，同时也不是绝对公平的。

临界区：

await与wait:

条件对象、条件变量：Condition可用于判断是否让出锁，可以调用await或wait，同时使用signal\signallAll来唤醒。

{
private final double□ accounts;
private Lock bankLock ;
private Condition sufficientFunds;

public Bank(int n, double initialBalance)
t
accounts = new double[n];
Arrays.fill(accounts, initialBalance);
bankLock = new ReentrantLockO;
sufficientFunds = bankLock.newCondition0；

2、sychronized

Lock 和 Condition 接口为程序设计人员提供了高度的锁定控制。然而，大多数情况下， 并不需要那样的控制，并且可以使用一种嵌人到 Java语言内部的机制。从 1.0 版开始，Java 中的每一个对象都有一个内部锁。如果一个方法用 synchronized关键字声明，那么对象的锁 将保护整个方法。也就是说，要调用该方法，线程必须获得内部的对象锁。

换句话说，
public synchronized void methodO
{
method body
}
等价于
public void methodQ
{
this.intrinsidock.1ock();
try
{
method body
}
finally { this.intrinsicLock.unlockO; }
}

wait、notifyAll 以及 notify 方法是 Object 类的 final 方法。Condition 方法必须被命 名为 await、signalAll 和 signal 以便它们不会与那些方法发生冲突。

每一个对象有一个内部锁， 并且该锁有一个内部条件。由锁来管理那些试图进入 synchronized 方法的线程，由条件来管理那些调用 wait 的线程。

将静态方法声明为 synchronized 也是合法的。如果调用这种方法，该方法获得相关的类对 象的内部锁。例如，如果 Bank 类有一个静态同步的方法，那么当该方法被调用时，Bankxlass 对象的锁被锁住。因此，没有其他线程可以调用同一个类的这个或任何其他的同步静态方法。

 同步阻塞：

还有 另一种机制可以获得锁，通过进入一个同步阻塞。当线程进入如下形式的阻塞：

synchronized (obj) // this is the syntax for a synchronized block

{

　　critical section

}

于是它获得 Obj 的锁。

不要视图获取同步阻塞对象的锁来保证同步。

监视器：

java 多线程

原文：https://www.cnblogs.com/baldprogrammer/p/13690671.html