###学习心得###
###心情###
今日掌握情况还可以,比昨天理解的透彻一点,线程方面对于加锁死锁有时候不知道什么时候放会更好,但是已经知道了锁的基本作用
锁:
1.synchronized多线程并发编程。
重量级锁。JDK1.6对synchronized进行了优化。
JDK1.6为了减少获得锁和释放锁带来的性能消耗引入的偏向锁和轻量级锁。
synchronized有三种方式来加锁,分别是:
- 1.修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁
- 2.静态方法,作用于当前类对象加锁,进入同步代码前要获得的当前类对象的锁
- 3.代码块,指定加锁对象,对给定对象加锁,进入同步代码块之前要获得给定对象的锁
1.实例方法:调用该方法的实例
2.静态方法:类对象
3.this:调用该方法的实例对象
4.类对象:类对象
操作共享数据的代码
共享数据:多个线程共同操作的变量,都可以充当锁
当使用同步方法时,synchronized锁的东西是this(默认的)
关于同步方法:
1.同步方法依然涉及到同步锁对象,不需要我们写出来
2.非静态的同步方法,同步锁就是this
静态的同步方法,同步监视器就是类本身
同步代码块:
1.选好同步监视器(锁)推荐使用类对象,第三方对象,this
2.在实现接口创建的线程类中,同步代码块不可以用this来充当同步锁
同步的方式,解决线程安全的问题。
操作同步代码时,只有一个线程能够参与,其他线程等待。相当于一个单线程的过程,效率低。
synchronized只针对于当前JVM可以解决线程安全问题。
synchronized不可以跨JVM解决问题!!!
加锁了的买票:---练习---
class Window3 extends Thread { private static int ticket = 100; private String name; public Window3(String name) { this.name = name; } @Override public void run() { sell(); } private synchronized void sell() { while(true) { if(ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(name + "卖票,剩余:" + ticket-- + "张!"); }else { break; } } } } public class Ch03 { public static void main(String[] args) { Window3 w1 = new Window3("窗口一"); Window3 w2 = new Window3("窗口二"); w1.start(); w2.start();
死锁:
死锁是这样一种情形:多个线程同时被阻塞,他们中的一个或者全部都在等待某个资源的释放,由于线程无限期的阻塞,程序就不可能正常终止。
java死锁产生四个必要条件
1.互斥使用,当资源被一个线程使用(占用),别的线程不能使用。
2.不可抢占,资源请求者不能强制从占有者中抢夺资源,资源只能从占有者手动释放
3.请求和保持
4.循环等待,存在一个等待队列。P1占有P2的资源,P2占有了P3的资源。P3占有P1的资源。形成了一个等待环路。
死锁:---练习---
class LockA implements Runnable { @Override public void run() { System.out.println(new Date().toString() + "LockA开始执行..."); try { while (true) { synchronized (Ch04.obj1) { System.out.println(new Date().toString() + "LockA锁住了obj1"); Thread.sleep(8000); } synchronized (Ch04.obj2) { System.out.println(new Date().toString() + "LockA锁住了obj2"); Thread.sleep(70*1000); } } } catch (InterruptedException e) { e.printStackTrace(); } } } class LockB implements Runnable { @Override public void run() { System.out.println(new Date().toString() + "LockB开始执行..."); try { while (true) { synchronized (Ch04.obj2) { System.out.println(new Date().toString() + "LockB锁住了obj2"); Thread.sleep(6000); //3s } synchronized (Ch04.obj1) { System.out.println(new Date().toString() + "LockB锁住了obj1"); Thread.sleep(100*1000); // 1min } } } catch (InterruptedException e) { e.printStackTrace(); } } } public class Ch04 { public static String obj1 = "obj1"; public static String obj2 = "obj2"; public static void main(String[] args) { LockA lockA = new LockA(); new Thread(lockA).start(); LockB lockB = new LockB(); new Thread(lockB).start();
线程重入:
任意线程在拿到锁之后,再次获取该锁不会被该锁所阻碍
线程不会被自己锁死的。
这就叫线程的重入,synchronized可重入锁。
JDK1.6以后锁升级:
1.无锁:不加锁
2.偏向锁:不锁锁,只有一个线程争夺时,偏向某一个线程,这个线程不加锁
3.轻量级锁:少量线程来了之后,向尝试自旋,不挂起线程。
4.重量级锁:排队挂起(暂停)线程。(synchronized)
挂起线程和恢复线程需要转入内核态中完成这些操作,给系统的并发性带来很大的压力。
在许多应用上共享数据的锁定状态,只会持续很短的时间,为了这段时间去挂起和恢复并不值得。我们可以让后面的线程等待一下,不要放弃处理器的执行时间。锁为了让线程等待,我们只需要让线程。执行一个循环,自旋。【自旋锁】
hashcode值1 0
public class Ch05 { private static final Object M1 = new Object(); private static final Object M2 = new Object(); public static void main(String[] args) { new Thread(() -> { synchronized (M1) { synchronized (M2) { synchronized (M1) { synchronized (M2){ System.out.println("hello lock"); } } } } }).start(); }
Object类对多线程的支持:
wait():
wait(long timeout):当前线程进入等待状态
notify():唤醒正在等待的下一个线程
notifyAll():唤醒正在等待的所有线程
线程间的通信:
比如两条线程,共同运行。 线程A如果先走,线程B就要等待。等待线程A走完,唤醒线程B,线程B再走
public class Ch01 { private static int num = 10; private static final Object OBJ = new Object(); public static void plus(int code,int i) { synchronized (OBJ) { if(num >= 10){ // 唤醒其他等待的线程 // OBJ.notify(); // 唤醒所有等待的线程 OBJ.notifyAll(); } System.out.println("这是线程" + code + "->" + ++num + "->" + i); } } public static void sub(int code,int i) { synchronized (OBJ) { if(num <= 0){ try { // 减法上来就是等待的状态 OBJ.wait(200); } catch (InterruptedException e) { throw new RuntimeException(e); } } System.out.println("这是线程" + code + "->" + --num + "->" + i); } } public static void main(String[] args) { Thread t1 = new Thread(() -> { for (int i = 0;; i++) { try { Thread.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } sub(1,i); } }); Thread t2 = new Thread(() -> { for (int i = 0;; i++) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } plus(2,i); } }); t1.start(); t2.start(); System.out.println("--------------------------------------------------");
方法总结:
1.Thread的两个静态方法:
sleep 释放CPU资源,但是不会释放锁
yield 方法释放CPU执行权,保留了CPU的执行资格,不常用。
2.join方法,yield出让了执行权,join就加入进来。
3.wait:释放CPU资源,释放锁
notify:唤醒等待中的线程
notifyAll:唤醒等待中的所有线程
线程的退出
使用退出标志,线程正常退出,run方法结束后线程终止
不要使用stop方法。
System.exit(-1)
class MyThread extends Thread { volatile boolean flag = true; @Override public void run() { while(flag) { try { System.out.println("线程一直在运行..."); int i = 10 / 0; } catch (Exception e) { this.stopThread(); } } } public void stopThread() { System.out.println("线程停止运行..."); this.flag = false; } } public class Ch03 { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start();
interrupt方法:
中断线程。
调用interrupt方法会抛出InterruptedException异常,捕获后再做停止线程的逻辑即可。 如果线程while(true)运行的状态,interrupt方法无法中断线程。
class MyThread02 extends Thread { private boolean flag = true; @Override public void run() { while(flag) { synchronized (this){ // try { // wait(); // } catch (InterruptedException e) { // e.printStackTrace(); // } try { sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); this.stopThread(); } } } } public void stopThread() { System.out.println("线程停止运行..."); this.flag = false; } } public class Ch04 { // public void show() { // try { // wait(); // // 线程异常终止 异常 // } catch (InterruptedException e) { // e.printStackTrace(); // } // } public static void main(String[] args) { MyThread02 myThread02 = new MyThread02(); myThread02.start(); System.out.println("线程开始..."); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // 中断线程的执行 myThread02.interrupt();
----------
----------