Java基础线程

多线程
 线程概念
         进程: 就是计算机中正在运行的程序所在内存的区域.
         线程: 源代码的执行路径,可以看成是进行中的子程序.
         注意:JVM是多线程虚拟机,最直观的看到一条执行路径,一条回收垃圾.
         线程的好处: 提高的程序的运行效率，可以保证多个程序一起运行
 用Thread类创建线程
         1) 继承Thread类.
         2) 重写Thread类中的run方法, 这时类已经是线程类了.
         3) 建立线程类的对象,其实就是创建一个线程.
         4) 调用线程start方法.
                a 开启线程.
                b JVM调用线程run方法.
 线程的特点:
         1) CPU控制线程的执行.
         2) CPU进行线程中的切换，随机切换,无法控制.
 用Runnable接口创建多线程
         1) 建立实现Runnable接口的实现类.
         2) 重写Run方法.(public Thread(Runnable target))
         3) 创建Thread类对象,传递Runnable的子类对象.
         4) 调用Thread类中的start方法.
         5) start方法开启线程,并调用Runnable接口子类对象中的Run方法.
 两种多线程创建的区别(继承Thread类和实现Runnable接口区别)
         1) 实现Runnable接口的方式,可以共享数据.
         2) 避免了继承的局限性.
 线程安全隐患
         1) 数据被多线程操作就容易出现安全隐患
         2) 数据是多线程的共享数据
         3) 解决安全问题前提:是不是多线程的程序和是不是持有同一把锁.
 synchronized关键字(同步)
         应用在线程操作的共享数据.
         格式:
                synchronized (参数) {}
        参数:
         1) 非静态的函数中所用的锁是this
         2) 静态里面用得是字节码class文件,类名.class
 死锁问题
         代码:
         /*
死锁
*/

class _dead implements Runnable                //实现Runnable接口
{
        boolean x = false;
        public void run()
        {
                while (true)
                {
                        if (x)
                        {
                                synchronized (_locka.a)
                                {
                                        System.out.println("if>>>locka");
                                synchronized (_lockb.b)
                                {
                                        System.out.println("if>>>lockb");
                                }

                                }
                               
                        }
                        else
                        {
                                synchronized (_lockb.b)
                                {
                                        System.out.println("else....lockb");
                                synchronized (_locka.a)
                                {
                                        System.out.println("else ... locka");
                                }
                                }
                        }
                }
        }
}
class _locka
{
        public static _locka a = new _locka();
}
class _lockb
{
        public static _lockb b = new _lockb();
}
class Test2
{
        public static void main(String[] args)
        {
                _dead d = new _dead();
                Thread t = new Thread(d);
                t.start();
                _dead d1 = new _dead();
                d1.x=true;
                Thread t1 = new Thread(d1);
                t1.start();
        }
}
 Thread方法常用参数介绍
         run负责线程中运行的代码
         Thread(String name),构造的时候，传递线程名
           getName()获取线程名
         setName()设置线程名
         Thread.currentThread().getName()获取线程名，在非Thread子类中使用
         start()开启线程，JVM调用线程的run方法
   安全高效的懒汉式
         /*
  单例模式中，懒汉不安全

  写一个，你认为安全的，效率较高的单例模式，要求懒汉
*/

class Single
{
        private Single(){}
        private static Single s = null;        //先给s变量赋null值
        public static Single show()
        {        //通过双if判断是否为null
                if (s== null)
                {
                if (s ==null)
                {
                        synchronized (Single.class)        //静态方法同步指向class文件
                        {
                        s = new Single();
                        }
                }else
                {
                        return s;
                }
                }
                return s;
        }
}
class Test implements Runnable
{
        public void run()
        {
                while (true)
                {
                        Single s = Single.show();
                        System.out.println(s);
                }
        }
}
class Test4
{
        public static void main(String[] args)
        {
                Test t = new Test();
                Thread t1 = new Thread(t);
                t1.start();

        }
}