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;
}
}
- 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
- 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
- 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
- 修改一个类，其作用的范围是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;
}
}
