Java多线程

1、多线程怎么用 ?是什么？进程和线程的区别？

进程：操作系统上一块独立的运行的程序，有自己的数据管理和其他进程数据是不共享的。
操作系统的一块独立区域，
线程：是一个程序中的并行线路之一，一个进程中可能会有多个线程。
1、多线程使用：
（1）thread

private void thread () {
   Thread thread = new Thread() {
          @Override
           public void run() {
                System.out.println("Thread started!");
            }
         }
     };
thread.start;

(2) runnable
可以重用runnable

private void runnable() {
    Runnable runnable = new Runnable() {
           @Override
            public void run() {
               System.out.println("Thread With Runnable Started!");
            }
         };
     Thread thread = new Thread(runnable);
     thread.start();
   }

(3)ThreadFactory
工厂方法的使用，统一的初始化线程操作，不用每一个线程都初始化一边线程操作。

ThreadFactory factory = new ThreadFactory() {
    @Override
    public Thread newThread(Runnable runnable) {
        return new Thread(runnable);
    }
};
Runnable runnable = new Runnable() {
    @Override
    public void run() {
          System.out.println("ThreadFactory print");
    }
};
Thread thread = factory.newThread(runnable);
thread.start();

(4) Executor
线程池 Executor

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("newCachedThreadPool print");
    }
};
//可缓存线程池,如果缓存中没有可用的，则移出60秒未使用过的线程
Executor executor = Executors.newCachedThreadPool();
//创建一个单线程的线程池
Executor executor = Executors.newSingleThreadExecutor();
//创建一个固定线程的线程池，可以用来处理集中瞬时爆发的任务
Executors.newFixedThreadPool(10);
//加延迟的线程池，支持定时和周期，一般情况下可替代timer
Executors.newScheduledThreadPool(10);
executor.execute(runnable);

(5) callable
相当于带返回值的runable

private void callable() {
   Callable<String> callable = new Callable<String>() {
        @Override
        public String call()  {
         try {
              Thread.sleep(1500);
          } catch (Exception e) {
              e.printStackTrace();
         }
           return "";
         }
    };
   ExecutorService service = Executors.newSingleThreadExecutor();
   Future<String> future = service.submit(callable);
   if (future.isDone()) {
       try {
           String result = future.get();
       } catch (ExecutionException | InterruptedException e) {
          e.printStackTrace();
      }
   }
}

2、线程同步：

原子性 : AtomicInteger,AtomicBoolean
(1）volatile 关键字
当写一个volatile变量时，JMM会把该线程本地内存中的变量强制刷新到主内存中去
(2）synchronized
1.修饰方法，修饰代码块

//修饰方法
private synchronized void count() {
        x += 1;
        y += 1;
    }

修饰代码块

//修饰修饰代码块
private void count() {
     synchronized (this) {
          x += 1;
          y += 1;
      }
 }

另外,修饰代码块可以指定锁

private Object object = new Object();
private void count() {
      synchronized (object) {
         x += 1;
         y += 1;
      }
  }

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

3.使用synchronized的例子，线程安全的单例模式

public class Singleton {
    //保证有序性，防止指令重排
    private static volatile Singleton singleton;

    public Singleton() {

    }

    private static Singleton getInstance() {
         //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (singleton == null) {
           //类对象加锁
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}