java多线程分析介绍

1.进程与线程的区别

　　　　1.1 进程通常是指一个应用程序，进程的启动就意味着该改程序的主线程启动，不同的进程拥有这不同的内存空间，而不同的线程有共享的内存空间，一个进程包含多个线程

2.java中如何创建线程

　　　　2.1 继承Thread类

　　　　2.2 实现Runnable接口

　　　　2.3 使用Callable和Future创建线程

3.线程中run()与start()的区别

　　　　3.1 run方法是指一个线程要执行的内容

　　　　3.2 start方法是指将线程的状态变成就绪状态,线程是否执行是取决于cup的调度

4.线程中的调度

　　　　4.1 sleep方法:线程休眠多长时间

　　　　4.2 join方法: 等待join方法的线程变成消亡状态

　　　　4.3 setPriority方法:设置线程的优先级，值越大 获取cup调度的资源就越大

　　　　4.4 yeild方法:线程让步,让当前线程变成就绪状态，虽然说是让步但是很有可能立即执行

　　　　4.5 stop方法:强制停止当前线程，但是这样做不安全，因此jdk标记成了过时方法

　　　　4.6 interrupt方法:优雅停止线程(设置一个可以停止线程的信号，实际上停止与否应该看线程所执行的业务结果可以通过isinterrupt来判断当前线程是否可以停止)

5.线程的状态

　　　　

 

6.并行于并发

　　6.1 并行真正的意义上的同时执行

　　6.2 通过CPU的调度,同一时刻只有一个线程执行

7.并发带来的问题

　　　多线程,原子,可见,有序,详细讲解:

　　　 7.1 原子性:同一个线程在执行的的时候不能被其他线程打断

　　　 7.2 可见性:当线程改变一个值后一定要让其他线程看到最新的结果 volitile:可见性关键字，保证线程一定能够获取到主内存最新更改的值

　　　 7.3 有序性:即程序执行的顺序按照代码的先后顺序执行

8.wait于sleep的区别

　　　1: wait是Object里边的发方法，sleep是Thread的方法

　　　2: wait会自动释放锁，sleep不会

　　　3: wait必须配合sychronized关键字一起使用

9.生产者与消费者模式notify与wait综合运用

package com.zhibo.zyw.bdqn;

/**
 * @program: Test
 * @author: zyw
 * @create: 2018-06-26 21:18
 **/
public class ProducerAndConsumer {

    public static int i = 0;
    public static Object monitor = new Object();

    public static void main(String[] args) {

package com.zhibo.zyw.bdqn;

/**
 * @program: Test
 * @author: zyw
 * @create: 2018-06-26 21:44
 * 消费者
 **/
public class Consumer implements Runnable {

    @Override
    public void run() {
        while (true) {
            synchronized (ProducerAndConsumer.monitor) {
                if (ProducerAndConsumer.i == 0) {
                    System.out.println("消费完毕开始生产");
                    try {
                        ProducerAndConsumer.monitor.notify();
                        ProducerAndConsumer.monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                ProducerAndConsumer.i--;
                System.out.println("消费一次,还剩" + ProducerAndConsumer.i);
                try {
                    Thread.sleep(30000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

/**
 * @program: Test
 * @author: zyw
 * @create: 2018-06-26 21:19
 * 生产者
 **/
public class Producer implements Runnable {
    @Override
    public void run() {

        while (true) {
            synchronized (ProducerAndConsumer.monitor) {

                if (ProducerAndConsumer.i == 5) {
                    System.out.println("生产完毕开始消费");
                    try {
                        ProducerAndConsumer.monitor.notify();
                        ProducerAndConsumer.monitor.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                ProducerAndConsumer.i++;
                System.out.println("生产一次，还剩" + ProducerAndConsumer.i);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

　　

 

10.实现死锁　　

　首先给大家先介绍一下死锁的概念,

　　　假设有a和b两个进程，都需要c和d两个资源，现在a持有c等待d资源，而b持有d等待c资源，两个都等待另一个资源而不肯释放资源，就这样无限等待中，这就形成死锁，这也是死锁的一种情况。给死锁下个定义，如果一组进程中每一个进程都在等待仅由该组进程中的其他进程才能引发的事件，那么该组进程是死锁的。下面小编带大家看一下代码形成死锁

　   　10.1 死锁实例

　　　　

package com.zhibo.zyw.bdqn;

/**
 * @program: Test
 * @author: zyw
 * @create: 2018-06-26 20:57
 **/
public class DeadLock implements Runnable {
    private static Object thread1 = new Object();
    private static Object thread2 = new Object();

    private Boolean lockFormer;

    public DeadLock(Boolean lockFormer) {
        this.lockFormer = lockFormer;
    }

    @Override
    public void run() {

        if (lockFormer) {

            synchronized (thread1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (thread2) {
                    System.out.println("1");
                }
            }
        } else {
            synchronized (thread2) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (thread1) {

                    System.out.println(2);
                }
            }
        }
    }
}

package com.zyw.test;

/**
 * @program: untitled
 * @author: zyw
 * @create: 2018-06-26 20:11
 **/
public class ThreadMan {

    public static void main(String[] args) {

        Thread thread =new Thread(new DeadLock(true));
        Thread thread1 =new Thread(new DeadLock(true));
        thread.start();
        thread1.start();
    }
}

线程A和线程B都没有得到自己的满足，就会形成死锁。

关于线程呢 小编今天就写到这里，有什么不太理解的欢迎大家评论留言！