标签：断线 特殊 自己 唤醒 单位 还需要 第一个 under 内存区域
新建一个线程有两种方法：继承Thread类，然后重写run方法；实现Runnable接口，然后实现run方法。实际上Thread类也是实现的Runnable接口，再加上类只能单继承，所以推荐使用Runnable接口。示例如下：
class Demo1 implements Runnable{ @Override public void run() { //新建线程需要执行的逻辑 } }
class Demo2 extends Thread{ @Override public void run() { //新建线程需要执行的逻辑 } }
对于Thread类，当然可以使用匿名内部类来简化写法：
Thread thread=new Thread(){ public void run(){ //新建线程需要执行的逻辑 } }; //Lambda表达式简化后 Thread thread=new Thread(()->{ //需要执行的逻辑 });
新建完一个线程后，就可以用对象实例来启动线程，启动后就会执行我们重写后的run方法：
thread.start();
此外，Thread类有个非常重要的构造方法：
public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); }
可见，传入的是一个Runnable类型的参数。为什么需要这个构造函数？因为Runnable接口只有一个run方法，如果我们直接实例化实现了这个接口的类，然后调用run方法，其实就和普通的类没有区别，并没有另外一个线程去执行run方法。说白了，Runnable并不是新建了一个线程，而只是线程里面执行任务的一种类型。在Java并发编程里，我们总是说的任务，很多时候就是Runnable类型的。所以我们还是需要把实现了Runnable接口的类的实例传入Thread的构造函数，然后通过start方法去调用Runnable的run方法。
//新建一个任务(Demo1实现了Runnable接口) Demo1 task=new Demo1; //新建一个线程并传入需要执行的任务 Thread thread=new Thread(task); //启动线程执行任务 thread.start();
熟悉了线程的创建，再简单了解一下操作线程的其他方法。
stop方法：作用是终止线程，但不推荐使用，因为它是强制结束线程，不管线程执行到了哪一步，很容易造成错误数据，引起数据不一致的问题。
interrupt方法：作用和stop类似，但是并不会那么粗鲁的终止线程，如果只调用这一个方法并不会中断线程，它还需要配合一个方法使用：
class Demo implements Runnable { @Override public void run() { //通过isInterrupted方法判断当前线程是否需要停止，不需要停止就执行逻辑代码 while (!Thread.currentThread().isInterrupted()){ //逻辑 } } } public class Use { public static void main(String[] args) throws InterruptedException { Demo task = new Demo (); Thread thread=new Thread(task); thread.start(); //通知thread可以终止了 thread.interrupt(); } }
wait方法和notify方法：这两个方法放在一起说，是因为它们需要配合使用。简单提一下synchronized ,这个会在在锁里面讲。synchronized大概的作用就是：代码块里的代码，同时只能由一个线程去执行，如何确保只有一个线程去执行？谁拥有锁谁就有资格执行。任何对象都可以调用wait方法，如obj.wait，它的意思就是让当前线程在obj上等待并释放当前线程占用的锁。obj.notify就是唤醒在obj上等待的线程并重新尝试获取锁。下面演示一下简单的使用：
public class Use { //一定要确保等待和唤醒是同一个对象，用类锁也可以，至于什么是类锁可以看后面synchronized部分 static Object object=new Object(); static int i = 0; static class Demo1 implements Runnable { @Override public void run() { synchronized (object){ for(int j=0;j<10000;j++){ i++; if(i==5000){ //1.因为t1先启动并进入同步代码块，所以首先输出5000 System.out.println(); try { //释放锁并等待 object.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } //3.被唤醒后接着执行完剩余的代码，输出20000 System.out.println(i); } } } static class Demo2 implements Runnable{ @Override public void run() { synchronized (object){ for(int j=0;j<10000;j++){ i++; } //2.获取到t1释放的锁，执行完代码后输出15000并唤醒object上等待的线程 System.out.println(i); object.notify(); } } } public static void main(String[] args) throws InterruptedException { Demo1 task1 = new Demo1(); Demo2 task2 = new Demo2(); Thread thread1=new Thread(task1); Thread thread2=new Thread(task2); thread1.start(); thread2.start(); } }
需要注意的是，如果有多个线程在obj等待，只执行一次obj.notify的话，它是随机从obj等待列表中选择一个线程唤醒的，如果要唤醒所有等待线程，可以使用obj.notifyAll。不管wait、notify还是notifyAll只能在synchronized代码块中使用，否则会报IllegalMonitorStateException异常。Java之所以这么规定，是确保不会发生Lost Wake Up问题，也就是唤醒丢失。上面那个例子中使用了同步代码块，所以不会发生这种问题。试想一种情况，如果没有synchronized确保线程是有秩序执行的，当t2线程先唤醒了object上的对象，t1线程后暂停的，那么t1是不是就永远会暂停下去，t2的notify相当于丢失了，这就是Lost wake up。
join方法：作用是让指定线程加入当前线程。为了节约篇幅还是以interrupt方法的代码为例，如果在main方法里调用thread.join()，那么主线程就会等待thread线程执行完才接着执行。其实这就和单线程的效果差不多了。如果有时候thread线程执行时间太长，为了不影响其他线程，我们可以在join方法里传入一个时间，单位是毫秒，当过了这个时间不管thread线程有没有执行完，主线程都会接着执行。join方法其实是通过wait方法实现的，注意这个wait是被加入线程等待，而不是加入的线程等待。贴一下源码，逻辑很简单就不复述了，如果join不传入参数，millis默认就是0：
public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }
yield方法：这个方法会让出当前线程的CPU，让出后还会接着去争夺，但是还能不能争夺到就不一定了。一般优先级比较低的线程，为了节约资源可以适当调用这个方法。
如何保证线程安全？无非就是锁的争夺。谁拥有了锁，谁才有资格执行。为什么只让一个线程执行代码？这就与Java的内存模型有关了。不了解的可以看其他资料，也可以看看我的另外一篇博客：https://www.cnblogs.com/lbhym/p/12458990.html，最后一节就是讲Java内存模型的。简单的说：线程共享的资源是放在一个共享内存区域的。当线程A去操作一个共享变量时，它会先把这个变量拷贝到自己私有的内存空间，然后进行操作，最后把操作后的值赋值到共享内存中的变量。如果在赋值之前另外一个线程B刚刚更新了这个值，那么线程A的操作就把线程B的操作给覆盖了，而线程B浑然不知，接着执行它的逻辑，这就造成了数据不一致的情况。所以我们必须加上一把锁，确保同一时间只能由一个线程来修改这个变量。
关键字synchronized的作用前面已经提到过了，下面给个简单的示例：
class Demo implements Runnable { static int i = 0; @Override public void run() { //小括号中的Demo.class就是锁，大括号内的代码同时只能由一个线程执行 synchronized (Demo.class){ for(int j=0;j<10000;j++) { i++; } } } } public class Use { public static void main(String[] args) throws InterruptedException { Demo task = new Demo(); Thread thread1=new Thread(task); Thread thread2=new Thread(task); thread1.start(); thread2.start(); //让两个线程加入主线程，这样就可以输出执行后的i了 thread1.join(); thread2.join(); System.out.println(Demo.i);//输出20000，如果去掉同步代码块，i绝对小于20000 } }
其实这个关键字的作用很好理解，关键在于，小括号里面有什么实际意义，它与Lock有什么区别？
首先synchronized和Lock都是Java里面的锁机制，前者用起来更加方便，后者功能更多。方便在哪？进入代码块前自动获取锁，如果锁已经被占，则会等待。执行完同步代码块中的内容，自动释放锁。而Lock需要手动加锁解锁，接下来会讲。
接着说说synchronized具体用法，小括号里就是锁对象。有一点需要注意，synchronized锁的是对象，而不是里面的代码，谁拥有指定的锁谁就能执行里面的代码。明白这一点有助于理解下面的内容。
synchronized的锁分为类锁和对象锁。它们的区别就是作用域的不同。
首先说说对象锁怎么用以及它的特点：
//对象锁： synchronized(this){...} synchronized(类的实例){...} //修饰在void前也是对象锁 public synchronized void run(){...}
如果synchronized里指定的是对象锁，那么在创建task时，不同的实例对象就是不同的锁。大家可以在上面示例代码的基础上，再用Demo类实例化一个task2，然后用thread去执行它，接着把synchronized小括号里的锁换成this，也就是对象锁，会发现输出的i小于20000。因为task和task2完全就是不同的锁，两个线程并不冲突，这就是为什么上面强调，锁的是对象，而不是里面的代码。
再说说类锁的用法和特点：
//类锁 synchronized(类名.class){...} //修饰在静态方法前也是类锁,run方法里直接调用handler就行 private synchronized static void handler(){...}
上面的示例代码就是一个类锁，即使实例化两个不同的对象，提交给两个线程执行后，输出结果肯定是20000，也就是说它们是同步的。
最后说一点，同一个类中，类锁和对象锁依旧是不同的锁，它们之间互不干扰，不是同步的。举个例子：
class Demo implements Runnable { static int i = 0; @Override public void run() { run2(); run3(); } //类锁 private synchronized static void run2(){ for(int j=0;j<10000;j++) { i++; } } //对象锁 private synchronized void run3(){ for(int j=0;j<10000;j++) { i++; } } }
main方法就不贴了，记得实例化一个task2给thread2执行。最后的输出结果肯定小于40000，如果把run3改成静态方法，也就是变成类锁，输出结果就是40000了。
Lock接口下提供了一套功能更完整的锁机制。如果项目中线程的竞争并不激烈，使用synchronized完全足够，如果竞争很激烈，还需要其他一些功能，这时候就可以尝试一下Lock提供的锁了。
简单的示例如下，说明也在注释当中:
class ReenterLock implements Runnable { //可重入锁，意思是：在同一个线程中，可以对lock多次加锁，当然也必须解锁对应次数 //那么Lock下的锁是类锁还是对象锁，取决于锁对象是类变量还是普通的全局变量，加上static就是类锁，反之就是对象锁 static ReentrantLock lock = new ReentrantLock(); static int i = 0; @Override public void run() { lock.lock(); for (int j=0;j<10000;j++){ i++; } lock.unlock(); } } public class 可重入锁 { public static void main(String[] args) throws InterruptedException { ReenterLock task = new ReenterLock(); Thread thread1=new Thread(task); Thread thread2=new Thread(task); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(ReenterLock.i); } }
可重入锁除了以上加锁、解锁的基本功能外，还有其他一些功能：
lockInterruptibly方法和interrupt方法：后者在线程中已经出现过一次了，虽然名字一样，功能也差不多，但是作用对象不一样。如果我们的线程在加锁也就是获取锁时，用的是lockInterruptibly方法，如果在等待一段时间后，还没获取到锁，那么就可以通过interrupt方法通知这个线程不用等了。这两个方法配合使用，在设置合理的等待时间后，可以避免死锁的发生。但需要注意，被通知放弃获取锁的线程会释放自己的资源，结束执行任务。
tryLock方法：除了上面那种外部通知放弃获取锁的方法外，还有一种限时等待的方法，tryLock有两个参数，第一个是时间，第二个是时间类型。如果不传入任何参数，获取到锁直接返回true，没获取到直接返回false。对的，tryLock和普通的lock方法不同，它返回的是Boolean类型，所以一般需要配合if判断使用：
@Override public void run() { try { if (lock.tryLock(10, TimeUnit.SECONDS)) { //逻辑代码 } } catch (InterruptedException e) { e.printStackTrace(); } }
公平锁和非公平锁：公平锁的分配是公平的，先到先得。非公平锁则是随机分配锁的，你先等待的不一定能先获取到锁。具体的是在ReenterLock构造函数中进行设置：
//构造函数传入true就是公平锁，默认情况下是非公平锁 static ReentrantLock lock = new ReentrantLock(true);
默认情况下采用非公平锁，是因为公平锁需要维护一个有序队列，性能相较于非公平锁是非常低的。
在synchronized代码块中，可以使用wait方法让当前线程释放锁并等待，然后通过notify方法唤醒线程并尝试重新获取锁。但是这两个方法是作用在synchronized中的，前面也说过了。在可重入锁也有类似的功能，下面举个简单的例子，会发现和synchronized中的wait和notify差不都：
public class Use { static ReentrantLock lock = new ReentrantLock(); //创建的lock的condition对象 static Condition condition = lock.newCondition(); static int i = 0; static class Demo1 implements Runnable { @Override public void run() { //t1先进来加锁(遇到一次特殊情况，t2后启动的反而先获取到锁了) lock.lock(); for (int j = 0; j < 10000; j++) { i++; if (i == 5000) { //1.输出5000 System.out.println(i); try { //释放锁并等待 condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } } //被唤醒后接着执行完剩下的代码，并输出20000 System.out.println(i); lock.unlock(); } } static class Demo2 implements Runnable { @Override public void run() { //获取锁 lock.lock(); for (int j = 0; j < 10000; j++) { i++; } System.out.println(i); //2.执行完后输出15000，并唤醒等待的线程 condition.signal(); lock.unlock(); } } public static void main(String[] args) throws InterruptedException { Demo1 task1 = new Demo1(); Demo2 task2 = new Demo2(); Thread thread1 = new Thread(task1); Thread thread2 = new Thread(task2); thread1.start(); thread2.start(); } }
await方法会使当前线程等待，同时释放当前锁，当其他线程中使用signal()方法或者signalAll()方法时，线程会重新获得锁并继续执行。或者当线程被中断时，也能跳出等待。这和Object.wait()方法相似。
awaitUninterruptibly方法与await方法基本相同，但是它并不会在等待过程中响应中断。
singal方法用于唤醒一个在等待中的线程，singalAll方法会唤醒所有在等待中的线程。这和Obejct.notify()方法很类似。
前面提到的可重入锁和同步代码块一次只能让一个线程进入，而Semaphore可以指定多个线程，同时访问一个资源。
public class Use { static int i = 0; //一次允许两个线程进入 static Semaphore sema = new Semaphore(2); static class Demo2 implements Runnable { @Override public void run() { try { //如果有多余的名额就允许一个线程进入 sema.acquire(); for(int j=0;j<10000;j++){ i++; } } catch (InterruptedException e) { e.printStackTrace(); }finally { //当前线程执行完代码并释放一个名额 sema.release(); } } } public static void main(String[] args) throws InterruptedException { //Demo1 task1 = new Demo1(); Demo2 task2 = new Demo2(); Thread thread1 = new Thread(task2); Thread thread2 = new Thread(task2); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(i);//输出小于20000，说明同时有两个线程进去了，互相干扰了。 } }
很多时候线程只是执行读操作，并不会互相干扰，其实这个时候并不需要线程之间相互排斥。在数据库里面读写锁是比较常见的，在Java中，它们的逻辑其实是一样的。只有读和读不会阻塞，有写操作必然阻塞。
代码篇幅太多了，就不再演示逻辑代码了，下面是读写锁的创建代码：
static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock(); //读锁 static Lock readLock=readWriteLock.readLock(); //写锁 static Lock writLock=readWriteLock.writeLock();
一个实用的多线程工具类，说倒计数器可能有点不明白，其实就是等来指定数量的线程执行完后才执行接下来的代码，看示例更清楚：
public class Use { //需要两个线程执行完任务 static CountDownLatch count = new CountDownLatch(2); static int i=0; static class Demo2 implements Runnable { @Override public void run() { synchronized (Use.class) { for (int j = 0; j < 10000; j++) { i++; } //当前线程执行完任务，计数器+1 count.countDown(); } } } public static void main(String[] args) throws InterruptedException { //Demo1 task1 = new Demo1(); Demo2 task2 = new Demo2(); Thread thread1 = new Thread(task2); Thread thread2 = new Thread(task2); thread1.start(); thread2.start(); //等待指定数量的线程都执行完任务后才接着执行，相当于阻塞了当前的主线程，从而实现了join的功能 count.await(); System.out.println(i);//输出20000 } }
标签：断线 特殊 自己 唤醒 单位 还需要 第一个 under 内存区域
原文地址：https://www.cnblogs.com/lbhym/p/12913280.html
