Java-多线程基本

Java-多线程基本
一 相关的概念
进程：是一个正在执行中的程序
每一个进程都有一个执行的顺序，该顺序是一个执行路径，或者叫一个控制单元

线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行

注意 ：
一个进程至少有一个线程

Java VM启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码在main方法中
该线程称为主线程

JVM启动不止一个线程，还有负责垃圾回收机制的线程

二 自定义创建线程
需要用到Thread类
创建方法一：
1.定义类继承自Thread

2.复写Thread中的run方法

3.调用线程的start方法，该方法有两个作用：启动线程，调用run方法

创建方法二：
1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法

3.通过Thread类建立线程对象

4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数：
原因是自定义的run方法所属的对象是Runnable接口的子类对象
所以要让线程去指定对象的run方法，就必须明确run方法的所属对象

5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

两种方式的区别：
方法二实现方式的好处：避免了单继承的局限性，建议使用实现的方式

多线程的特性：随机性，由于cpu的分时调度规则(在某一个时刻，cpu只运行一个程序，cpu在运行过程中做着快速的切换)，至于执行的时间，cpu说的算

对象调用run和start的区别：
start：开启线程并执行该线程的run方法
run：仅仅是对象调用方法，而且线程创建了，并没有运行

多线程的运行状态：
创建，运行，消亡，阻塞，冻结
如下图：

多线程常用的方法：
static Thread currentThread()获取当前线程对象
getName()获取线程名称，线程名称默认格式为Thread-0(1,2,3…..)
setName或者构造函数可以设置线程名称

三 多线程的安全问题：

解决线程操作数据时的时间差问题需要用到
1，同步代码块

synchronized(对象锁)
{

    需要同步的代码；
}

2，同步函数
就是将synchronized关键字加到函数上

public synchronized void Test()
{

}

如何找出线程的安全隐患：
1.明确哪些代码是多线程运行代码
2.明确共享的数据
3.明确多线程运行代码中哪些语句是操作共享数据的

三 锁
锁：
锁就是一个对象
同步函数的锁死this，
静态同步函数的锁是该方法所在类的字节码文件对象。类名.class对象：静态方法中不可以定义this，静态方法进入内存，内存中还没有本类的对象
但是一定有该类对应的字节码文件对象，类名.class，该对象的类型是class

死锁：两个线程相互争夺锁的情况

下面是一个面试题：写一个死锁的Demo

class Test implements Runnable
{
    private boolean flag;
    Test(boolean p_flag)
    {
        this.flag = p_flag;
    }

    public void run()
    {
        if (flag)
        {
            while (true)
            {
                synchronized(MyLock.locka)
                {
                    System.out.println("if locka");
                    synchronized(MyLock.lockb)
                    {
                        System.out.println("if lockb");

                    }
                }
            }
        }
        else
        {
            while (true)
            {
                    synchronized(MyLock.lockb)
                {
                     System.out.println("if lockb");
                                     synchronized(MyLock.locka)
                         {
                        System.out.println("if locka");

                     }
                     }
            }

        }

    }

}
//锁对象
class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object();

}


class TestDemo
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(new Test(true));
        Thread t2 = new Thread(new Test(false));
        t1.start();
        t2.start();


    }
}

四 多线程与单例设计模式：
主要是懒汉式的问题：

class Singel 
{
    private static Singel s = null;
    private Singel();

    public static Singel getInstance()
    {
            //双重判断可以解决效率低的问题
        if (null == s)
        {
            //synchronized关键字比起在函数上同步更加高效
            synchronized(Singel.class)//使用的本类文件的锁
            {
                if (null == s)
                {
                    s = new Singel();
                }
            }
            return s;
        }

    }
}

上面的代码需要记住，面试可能会问到