java多线程处理怎么避免重复处理 java多线程重点

1.多线程的创建

• 继承Thread类
• 实现Runnable接口
• 匿名类

2.常见线程方法

• 暂停当前线程：Thread.sleep(1000)
• 加入主线程：t1.join()，主线程会等待该线程结束才会继续往下运行
• 设置线程优先级：t1.setPriority(Thread.MAX_PRIORITY)、t1.setPriority(Thread.MIN_PRIORITY)
• 临时暂停：Thread.yield()
• 设置守护线程：t1.setDaemon(true)

3.同步

• 同步问题的产生原因：多个线程同时在操作一个对象
• 同步问题的解决思路：有线程在操作对象时其他线程无法访问该对象
• Synchronized同步对象概念：

a.synchronized表示当前线程独占了同步对象，如果其他线程试图占有对象，就会等待；直到当前线程释放对同步对象的占用

b.多线程的操作需要建立在占有同步对象的基础上，而同步对象在同一时间也只能被一个线程占有；间接地同一时间，同步对象只能被一个线程修改。

c.释放同步对象的方式：synchronized块自然结束或有异常抛出

• Synchronized解决同步问题：任意对象都可以成为同步对象，包括实例对象、this、类方法
• 线程安全的类

a.如果一个类，其方法都是有synchronized修饰的，那么该类就该叫做线程安全的类；同一时间只有一个线程能够进入这种类的一个实例去修改数据，进而保证了这个实例中数据的安全（不会同时被多线程而变成脏数据）

b.常见线程安全相关的面试题：

1.HashMap和Hashtable的区别一：HashMap可以存放null，Hashtable不能存放null;

2.StringBuffer和StringBuilder的区别一：StringBuffer是线程安全的，StringBuilder是非线程安全的；区别二：当进行大量字符串拼接操作的时候，如果是单线程就用StringBuilder会更快些；如果是多线程，就需要使用StringBuffer保证数据的安全性

3.ArrayList和Vector的区别：类声明一致，区别在于Vector是线程安全的类，而ArrayList是非线程安全的。

4.把非线程安全的集合转换为线程安全：ArrayList是非线程安全的，多个线程可以同时进入一个ArrayList对象的add方法；借助Collections.synchronizedList，可以把ArrayList转换为线程安全的List。与此类似的还有HashSet,LinkedList,HashMap等非线程安全的类，都可以通过工具类Collections转换为线程安全的。

4.死锁

• 当业务比较复杂，多线程应用里有可能会发生死锁：a.线程1首先占有对象1，接着试图占有对象2；b.线程2首先占有对象2，接着试图占有对象1；c.线程1会等待线程2释放对象2；d.线程2会等待线程1释放对象1；e.两个线程就会一直等待下去。。。                                                                        

5.交互

• 线程之间有交互通知的需求：

　　　　a.不好的解决方式：线程中使用while等循环语句去处理判断语句，会大量占用CPU，拖慢性能；

b.使用wait和notify进行线程交互：

　　　　（1）this.wait()表示让占有this的线程等待，并临时释放占有；

　　　　（2）this.notify()表示唤醒那等待在this的线程；

c.关于wait、notify、notifyAll：

　　　　（1）wait方法和notify方法并不是Thread线程上的方法，它们是Object上的方法；因为所有的Object都可以用来作为同步对象，所以准确的来说，wait和notify是同步对象上的方法。

　　　　（2）wait()的意思是：让占用了这个同步对象的线程，临时释放当前的占用并且等待；所以调用wait是有前提条件的，一定是在sycnhronized块里，否则就会出错。

　　　　（3）notify()的意思是：通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。

　　　　（4）notifyAll()的意思是：通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。

d.线程交互：【练习题】假设加血线程运行得更加频繁，Hero类属性hp最大值是1000；设计加血线程和减血线程的交互，让回血回满之后，加血线程等待，直到有减血线程减血。

　　　　   Hero类回血、减血方法实现：

               

线程实例化：

               

e.多线程交互：【练习题】在前面练习的基础上，增加回血线程到2条，减血线程到5条，同时运行；运行一段时间后，观察会发生的错误，分析错误原因并考虑解决办法。

错误：在目前的状态下，会导致hp变为负数；这是因为减血线程调用hurt()方法结束后，调用notify有可能唤醒另一个减血线程，这就导致hp会不停的减下去。

　　　  　 

解决办法：减血线程被唤醒后，要再次查看当前hp；如果当前hp<=1，那么就继续等待。把if改为while，当线程被唤醒后会重复查看hp的值，只有hp大于1才会继续往下执行。

　　　　   

f.生产者消费者问题：生产者消费者问题是一个非常典型性的线程交互的问题。

　　　　（1）使用栈来存放数据

　　　　　　（1.1）把栈改造为支持线程安全

　　　　　　（1.2）把栈的边界操作进行处理，当栈里的数据是0的时候，访问pull的线程就会等待。当栈里的数据是200的时候，访问push的线程就会等待。

　　　　（2）提供一个生产者(Producer)线程类，生产随机大写字符压入到堆栈

　　　　（3）提供一个消费者(Consumer)线程类，从堆栈中弹出字符并打印到控制台

　　　　（4）提供一个测试类，使两个生产者和三个消费者线程同时运行，结果类似如下：

  通过LinkList实现Stack：

　　　　　　

　　　　　　  ProducerThread线程类实现：

　　　　　　

ConsumerThread线程类实现：

　　　　　　

测试类：

　　　　　　

6.线程池

• 每一个线程的启动和结束都是比较消耗时间和占用资源的，如果在系统中用到了很多的线程，大量的启动和结束动作会导致系统的性能变卡，响应变慢；为了解决这个问题，引入线程池这种设计思想。线程池的模式很像生产者消费者模式，消费的对象是一个一个的能够运行的任务。

a.线程池设计思路

　　（1）准备一个任务容器

　　（2）一次性启动10个消费者线程

　　（3）刚开始任务容器是空的，所以线程都wait在上面

　　（4）直到一个外部线程往这个任务容器扔了一个“任务”，就会有一个消费者线程被唤醒notify

　　（5）这个消费者线程取出“任务”，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

　　（6）如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务

　　在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程。

b.开发一个自定义线程池

           　　

ThreadPool.java

public class ThreadPool {

    int threadPoolSize;     // 线程池大小
    LinkedList<Runnable> tasks = new LinkedList<>();    // 任务容器
    public ThreadPool() {   // 试图消费任务的线程
        threadPoolSize = 10;
        synchronized (tasks) {
            for (int i = 0; i < threadPoolSize; i++) {  // 启动10个任务消费者线程
                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) {
                            e.printStackTrace();
                        }
                    }
                    task = tasks.removeLast();  // 取出最后的对象
                    tasks.notifyAll();  // 允许添加任务的线程可以继续添加任务
                }
                System.out.println(this.getName() + " 获取到任务，并执行");
                task.run();
            }
        }
    }
}
TestThread.java

public class TestThread5 {
    public static void main(String[] args){
        ThreadPool pool = new ThreadPool();
        int sleep = 1000;
        while(true){
            pool.add(new Runnable() {
                @Override
                public void run() {
                    try{
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            try{
                Thread.sleep(sleep);
                sleep = sleep>100?sleep-100:sleep;
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

c.使用java自带线程池

线程池类ThreadPoolExecutor在包java.util.concurrent下，

ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

第一个参数 10表示这个线程池初始化了10个线程在里面工作；

第二个参数 15表示如果10个线程不够用了，就会自动增加到最多15个线程；

第三个参数 60结合第四个参数TimeUnit.SECONDS表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个；

第四个参数 TimeUnit.SECONDS如上；

第五个参数 new LinkedBlockingQueue()用来放任务的集合；

execute方法用于添加新的任务。

public class TestThread {
    public static void main(String[] args) throws InterruptedException{
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务1");
            }
        });
    }
}

7.Lock对象

8.原子访问