java_learing29 死锁

1. 死锁

    public class ThreadTst {
    public static void main(String args[]){
        StringBuffer s1= new StringBuffer();
        StringBuffer s2= new StringBuffer();
        new Thread(new Runnable(){
            @Override
            public void run() {
                //super.run();
                synchronized(s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);//这里直接写100，前面的millis是自动添加的
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                synchronized(s2){
                    s1.append("b");
                    s2.append("2");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }).start();
    new Thread(new Runnable(){
        @Override
        public void run() {
            //super.run();
            synchronized(s2){
                s1.append("c");
                s2.append("3");
                try {
                    Thread.sleep(100);//这里直接写100，前面的millis是自动添加的
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(s1){
                    s1.append("d");
                    s2.append("4");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }
    }).start();
   

   }
   }

2. 死锁的结果——程序既不会抛异常，也不会终止，无法继续，但是线程的最终目的是死亡，因此这种状态是需要避免的
   

3.  import java.util.concurrent.locks.ReentrantLock;
   
    class Window implements Runnable {
    private int ticket = 100;
    //1.实例化Reentrantlock
    private ReentrantLock lock=new ReentrantLock(true);
   
    @Override
    public void run() {
        while (true) {
            try {
                //2.调用lock()
                lock.lock();
   
            if (ticket > 0) {
   
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
   
                System.out.println(Thread.currentThread().getName() + ":售票，票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }finally{
            //3.调用解锁方法
            lock.unlock();
        }
    }
    }
    }
    	public class DeadLock {
    	            public static void main(String[] args) {
    	                Window w = new Window();
    	                Thread t1 = new Thread(w);
    	                Thread t2 = new Thread(w);
    	                Thread t3 = new Thread(w);
    	
                t1.setName("窗口1");
                t2.setName("窗口2");
                t3.setName("窗口3");
   
                t1.start();
                t2.start();
                t3.start();
            }
   
   
    }
   

4. synchronized 与 lock不同
   1. 相同点：都可以用来解决线程安全问题
   2. 不同点：
   1. synchronized机制在执行完相应的同步代码之后，自动释放同步监视器（隐式锁），lock则需要手动的启动同步，结束同步（显式锁）
   2. Lock只有代码块锁，synchronized有代码块锁和方法锁
   3. 优先使用顺序：
   1. Lock→同步代码块（已经进入方法体，分配了相应资源）→（在方法体之外）
   2. Lock毕竟是新特性，建议使用，而且使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）。

5. 相关面试题
   1. 线程与进程
   1. 运行的程序——进程
   2. 进程的执行路径——线程
   3. 线程是cpu调度的最小单位，进程是资源分配的最小单位
   2. 多线程是什么
   1. 一个进程的多条执行路径，且一个线程的结束不会影响同一进程的其他线程的结束
   2. 提高程序的使用效率
   3. 多线程是实现并发的一种手段
   3. 并行与并发
   1. 并行——同一时间多个处理器同时执行多个程序
   2. 并发——同时处理多个任务
   1. 吃一口饭，说一句话是并发，靠一张嘴也能做到
   2. 吃饭的同时说话是并行，靠一张嘴做不到
   3. 如果某个系统支持两个或者多个动作（Action）同时存在，那么这个系统就是一个并发系统。如果某个系统支持两个或者多个动作同时执行，那么这个系统就是一个并行系统。并发系统与并行系统这两个定义之间的关键差异在于“存在”这个词。在并发程序中可以同时拥有两个或者多个线程。这意味着，如果程序在单核处理器上运行，那么这两个线程将交替地换入或者换出内存。这些线程是同时“存在”的——每个线程都处于执行过程中的某个状态。如果程序能够并行执行，那么就一定是运行在多核处理器上。此时，程序中的每个线程都将分配到一个独立的处理器核上，因此可以同时运行。我相信你已经能够得出结论——“并行”概念是“并发”概念的一个子集。也就是说，你可以编写一个拥有多个线程或者进程的并发程序，但如果没有多核处理器来执行这个程序，那么就不能以并行方式来运行代码。因此，凡是在求解单个问题时涉及多个执行流程的编程模式或者执行行为，都属于并发编程的范畴。

    4. 创建多线程的方法
    		1. 继承Thread类，
    		2. 重写run()方法
    5. 多线程与多进程（的选择）——这个问题暂时不用答，高难
    		1. 由于多个线程之间是共享资源的，所以多线程切换开销小于多进程
    6. 多线程与高并发
    		1. 高并发就是系统在运行过程中收到大量请求的情况，或者说一种状态
    		2. 多线程则是让系统能够承受高并发状态的一种手段
    7. 判断是否是多线程
    8. java程序每次运行至少启动几个线程
    		main线程和GC
    9. 多线程就一定会涉及线程安全问题吗？
    		不一定，有无线程安全问题取决于有无共享数据
    10.  如何解决线程问题，有几种方法？
    		3种方式