本文是学习笔记来自于 How2J网站 强烈推荐!
一.创建线程的三种方法
1.继承Thread类
public class KillThread extends Thread{}
然后在主函数中这样调用:
KillThread killThread1 = new KillThread(gareen,teemo);
killThread1.start();
2.实现Runnable接口
public class Battle implements Runnable{
然后在主函数中这样调用:
Battle battle1 = new Battle(gareen,teemo);
new Thread(battle1).start();
3.匿名类
类似于这样:
Thread t1= new Thread(){
public void run(){
///Code
}
};
t1.start();
注： 启动线程是start()方法，run()并不能启动一个新的线程
二.常见线程方法
1.sleep方法
线程暂停一会儿, 单位是毫秒ms
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
2.join方法
把某个线程加入到主线程(main线程)的方法
t1.join();
3.线程优先级
设置优先级让某个线程更有机会获得运行的机会:
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
这个优先级是会自动和运行的系统的任务优先级对应的, Java中的优先级是从1到10;
4.临时暂停
是静态方法, 让其他线程更有机会运行;
Thread.yield();
5.守护线程
守护线程通常会被用来做日志，性能统计等工作。 可以做计时器;
t1.setDaemon(true);
三.同步
多线程的同步问题指的是多个线程同时修改一个数据的时候，可能导致的问题;
比如i++这个操作, 是有可能发生同步问题的:
假设在某一时刻, 线程a进行i++操作, 它会
1.先取出i的值
2.然后计算i+1的值
3.最后把计算出的值存入i变量
在上述的三步中, 有可能在运行第1步和第3步之间, 另外一个线程b也希望进行i++操作, 因为此时线程a还没有把i的值存入, 所以获取到的值仍是没有自增的i, 所以有可能在线程a和b中同时执行i++的结果是i只加了1;
要解决这个问题就是要使用锁:
1.创建一个同步的对象锁
Object someObject =new Object();
synchronized (someObject){
//此处的代码只有占有了someObject后才可以执行
}
2.使用要操作的对象作为锁
synchronized(account){
account.credit();
}
3.在对象的方法内部使用锁
在account类的内部credit方法中
public void credit(int num){
synchronized(this){
this.balance+=num;
}
}
4.把synchronized作为方法的关键字修饰符
public synchronized void credit(int num){
this.balance+=num;
}
四.线程安全的类
如果一个类，其方法都是有synchronized修饰的，那么该类就叫做线程安全的类
1.HashMap和Hashtable
HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null
Hashtable不能存放null
区别2：
HashMap不是线程安全的类
Hashtable是线程安全的类
2.StringBuffer和StringBuilder
StringBuffer 是线程安全的
StringBuilder 是非线程安全的
3.ArrayList和Vector的区别
Vector是线程安全的类，而ArrayList是非线程安全的
4.把非线程安全的集合转换为线程安全
借助Collections.synchronizedList可以把ArrayList转换为线程安全的List。
与此类似的，还有HashSet,LinkedList,HashMap等等非线程安全的类，都通过工具类Collections转换为线程安全的
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = Collections.synchronizedList(list1);
五.死锁
- 线程1 首先占有对象1，接着试图占有对象2
- 线程2 首先占有对象2，接着试图占有对象1
- 线程1 等待线程2释放对象2
- 与此同时，线程2等待线程1释放对象1
就会。。。一直等待下去，直到天荒地老，海枯石烂，山无棱 ，天地合。。。
六.线程间交互
使用wait和notify做线程间交互:
public synchronized void recover() {
hp = hp + 1;
System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
// 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
this.notify();
}
public synchronized void hurt() {
if (hp == 1) {
try {
// 让占有this的减血线程，暂时释放对this的占有，并等待
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
hp = hp - 1;
System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
}
这里需要强调的是，wait方法和notify方法，并不是Thread线程上的方法，它们是Object上的方法。
因为所有的Object都可以被用来作为同步对象，所以准确的讲，wait和notify是同步对象上的方法。
wait()的意思是： 让占用了这个同步对象的线程，临时释放当前的占用，并且等待。 所以调用wait是有前提条件的，一定是在synchronized块里，否则就会出错。
notify() 的意思是，通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。
notifyAll() 的意思是，通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。
七.线程池
线程池的思路是这样的:
- 准备一个任务容器
- 一次性启动10个 消费者线程
- 刚开始任务容器是空的，所以线程都wait在上面。
- 直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒notify
- 这个消费者线程取出“任务”，并且执行这个任务，执行完毕后，继续等待下一次任务的到来。
- 如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务。
在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程;
一个自定义线程池的例子:
package multiplethread;
import java.util.LinkedList;
public class ThreadPool {
// 线程池大小
int threadPoolSize;
// 任务容器
LinkedList<Runnable> tasks = new LinkedList<Runnable>();
// 试图消费任务的线程
public ThreadPool() {
threadPoolSize = 10;
// 启动10个任务消费者线程
synchronized (tasks) {
for (int i = 0; i < threadPoolSize; i++) {
new TaskConsumeThread("任务消费者线程 " + i).start();
}
}
}
public void add(Runnable r) {
synchronized (tasks) {
tasks.add(r);
// 唤醒等待的任务消费者线程
tasks.notifyAll();
}
}
class TaskConsumeThread extends Thread {
public TaskConsumeThread(String name) {
super(name);
}
Runnable task;
public void run() {
System.out.println("启动： " + this.getName());
while (true) {
synchronized (tasks) {
while (tasks.isEmpty()) {
try {
tasks.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
task = tasks.removeLast();
// 允许添加任务的线程可以继续添加任务
tasks.notifyAll();
}
System.out.println(this.getName() + " 获取到任务，并执行");
task.run();
}
}
}
}
使用Java自带的线程池:
ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
threadPool.execute(new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("任务1");
}
});
线程初始化的构造器中
第一个参数10 表示这个线程池初始化了10个线程在里面工作
第二个参数15 表示如果10个线程不够用了，就会自动增加到最多15个线程
第三个参数60 结合第四个参数TimeUnit.SECONDS，表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个
第四个参数TimeUnit.SECONDS 如上
第五个参数 new LinkedBlockingQueue() 用来放任务的集合
execute用于添加新的任务
八.Lock锁
相同于synchronized关键字, 也可以用Lock对象锁
Lock lock = new ReentrantLock();
Thread t1 = new Thread() {
public void run() {
try {
log("线程启动");
log("试图占有对象：lock");
lock.lock();
log("占有对象：lock");
log("进行5秒的业务操作");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log("释放对象：lock");
lock.unlock();
}
log("线程结束");
}
};
lock对象提供了一个trylock方法, 可以提供一个时间, trylock会在指定时间范围内试图占用，占成功了，就啪啪啪。 如果时间到了，还占用不成功，扭头就走~
boolean locked = false;
try {
log("线程启动");
log("试图占有对象：lock");
locked = lock.tryLock(1,TimeUnit.SECONDS);
if(locked){
log("占有对象：lock");
log("进行5秒的业务操作");
Thread.sleep(5000);
}
else{
log("经过1秒钟的努力，还没有占有对象，放弃占有");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked){
log("释放对象：lock");
lock.unlock();
}
}
使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法
Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法
总结synchronized和lock的区别:
-
Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
-
Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。
-
synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。
九.原子性
所谓的原子性操作即不可中断的操作，比如赋值操作
int i = 5;
原子性操作本身是线程安全的
但是像i++这样的操作就不是原子性的
JDK6 以后，新增加了一个包java.util.concurrent.atomic，里面有各种原子类，比如AtomicInteger。
而AtomicInteger提供了各种自增，自减等方法，这些方法都是原子性的。 换句话说，自增方法 incrementAndGet 是线程安全的，同一个时间，只有一个线程可以调用这个方法。
AtomicInteger atomicI =new AtomicInteger();
int i = atomicI.decrementAndGet();
int j = atomicI.incrementAndGet();
int k = atomicI.addAndGet(3);