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;
        }

    }
}

上面的代码须要记住。面试可能会问到