Java的多线程安全

一，创建线程的几种方式：

public class futureTask_test {
        public static void main(String[] args) throws InterruptedException, ExecutionException {
            //创建futureTask
            FutureTask<Integer> task=new FutureTask<Integer>(()->{
                System.out.println("hello");
                Thread.sleep(3000);
                
                return 1000;
            });
            
            //传入thread中
            Thread t1=new Thread(task,"t1");
            t1.start();
            System.out.println(task.get());
            
            
        }
}

 二，jconsole

Jconsole支持对本地和远程Java进程的监控。 

 

1.     监控本地Java进程

对于本地的Java进程很简单，只需要在启动需要监控的Java程序后，启动Jconsole，在本地进程列表中选择该进程点击“连接”按钮即可。例如，我们先启动JDK自带的另一个监控工具JVisualVM，然后启动JConsole：

在JConsole的本地进程列表中可以看到JVisualVM进程，选择并连接之。
 

2.    监控远程Java进程

2.1  设置远程监控相关选项

对于远程Java进程的连接，会要麻烦些，首先需要在需监控的远程Java程序启动脚本中加入与JVM远程监控相关的选项：
1)     开启JVM远程监控
        -Dcom.sun.management.jmxremote=true

2)     监控的IP地址
         -Djava.rmi.server.hostname=192.168.91.166，远程进程所在主机的IP。

3)     监控的端口
        -Dcom.sun.management.jmxremote.port=50013，这个端口值可以任意设置，但在之后用Jconsole连接这个远程进程的时候，远程进程中的port一定要和此处的设置一致，并且一定不要和远程进程的服务端口区分开。

4)     是否禁用ssl验证
        -Dcom.sun.management.jmxremote.ssl，false为禁用，true为启用。

5)     是否需要用户密码验证
        -Dcom.sun.management.jmxremote.authenticate，false为不需要验证，true为需要验证。但我在Win7(32位、64位)中tomcat5.5.23下试着将该选项设置为true，tomcat无法启动，命令行窗口一闪而过。

        有试过象参考文献中所说的，修改jdkjre及jre下的jmxremote.password和jmxremote.access，又有尝试象参考文献4中所说的，修改jdkjre及jre下结果也是一样的。结果也是一样的management.properties，结果均一样的。
        
         有哪位遇到过，并解决了这个问题，如果看到这儿的，希望可以帮忙解答一下，先谢过了！！ 


2.2  连接远程Java进程

有两种连接远程Java进程的方法，效果是一样的。

1)     命令行中连接远程Java进程
        直接在命令行中启动JConsole的时候，带远程进程参数:
 

2)     JConsole图形界面上连接远程Java进程

先在命令行中不带远程进程参数启动JConsole，然后在JConsole新建连接对话框中选择远程进程，填入远程进程参数:，最后点击“连接”按钮。

java -cp . -Dcom.sun.management.jmxremote.port=8999 -Dcom.sun.managent.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false JConsoleTest
二，两阶段终止模式

public class TwoPhaseTermination {

 public static void main(String[] args) throws InterruptedException {
    Monitor monitor=new Monitor();
    monitor.startMon();
    
    Thread.sleep(3500);
    monitor.stop();
}
}

class Monitor{
    private Thread monitor;//监视器线程
     
     //开始监视的方法
     public void startMon() {
         //定义线程
         monitor=new Thread(()->{
             while(true) {
                 //获取打断标记
                 boolean interrupted=Thread.currentThread().isInterrupted();
                 if(interrupted) {//被打断了
                     System.out.println("我被打断了，正在处理后事。。");
                     break;
                 }else {//未被打断
                     try {
                        Thread.sleep(1000);//让出时间片
                        //未出现异常
                        System.out.println("我开始执行监控事情");
                    } catch (InterruptedException e) {
                        // TODO: handle exception
                        //未出现异常，被打断了
                        //interrupted=true;不能用这种方式来改变打断标志
                        //
                        monitor.interrupt();
                        
                    }
                     
                 }
             }
         });
         
         //开启线程
         monitor.start();
         
     }
     
     //停止监控
     public  void stop() {
        monitor.interrupt();
    }
     
}

 三，保护性暂停模式

public class GuardedSuspension {
    private int id;
    
    public GuardedSuspension(int id) {
        this.id=id;
    }

    public int getId() {
        return id;
    }

    

    public Object getResponse() {
        return response;
    }

    

    private Object response;
    
    public Object get(long timeout) {
        synchronized (this) {
            long begin=System.currentTimeMillis();
            long passtime=0;
            if(response==null) {
                //没有数据
                try {
                    long waittime=timeout-passtime;
                    this.wait(waittime);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                passtime=System.currentTimeMillis()-begin;
            }
            return response;
        }
    };
    
    public void set(Object o) {
        synchronized (this) {
            this.response=o;
            this.notifyAll();
            
        }
    };
}

升级的解耦：

public class Mailboxs {
    private static  int id=1;
    private static synchronized int  generateId() {
        return id++;//自增id
    }
    private static Map<Integer, GuardedSuspension> boxes=new Hashtable<Integer, GuardedSuspension>();//保证线程安全
    public static GuardedSuspension createGuardedSuspension(int id) {
        
        //加入邮箱,取信
    return    boxes.remove(id);
        
        
    }
    public static GuardedSuspension getGuardedSuspension() {
        GuardedSuspension go=new GuardedSuspension(generateId());
        //加入邮箱,送信
        boxes.put(go.getId(),go);
        return go;
        
    }
    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
    
    
}

 四，顺序执行

public class Secquence extends ReentrantLock{
    
    public static void main(String[] args) {
        Secquence secquence=new Secquence();
        Condition a=secquence.newCondition();
        Condition b=secquence.newCondition();
        Condition c=secquence.newCondition();
        Thread t1=new Thread(()->{
            secquence.showInfo("a", a, b);
        },"t1");
        Thread t2=new Thread(()->{
            secquence.showInfo("b", b, c);
        },"t2");
        
        Thread t3=new Thread(()->{
            secquence.showInfo("c", c, a);
        },"t3");
        t1.start();
        t2.start();t3.start();
        
        //主线程开启
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        secquence.lock();
        try {
            System.out.println("开始");
            a.signal();
        }finally {
            secquence.unlock();
        }
    }
    
    //多线程的顺序执行
    
    private static int loopNumber=5;
    //打印方法
    public void showInfo(String str,Condition current,Condition next) {
        for(int i=0;i<loopNumber;i++) {
            lock();
            try {
                
                current.await();
                System.out.print(str);
                next.signal();
                
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                // TODO: handle exception
                unlock();
            }
        }
        
    }
    
}

public class Secquence extends ReentrantLock{
    
    public static void main(String[] args) {
        Secquence secquence=new Secquence();
        Condition a=secquence.newCondition();
        Condition b=secquence.newCondition();
        Condition c=secquence.newCondition();
        Thread t1=new Thread(()->{
            secquence.showInfo("a", a, b);
        },"t1");
        Thread t2=new Thread(()->{
            secquence.showInfo("b", b, c);
        },"t2");
        
        Thread t3=new Thread(()->{
            secquence.showInfo("c", c, a);
        },"t3");
        t1.start();
        t2.start();t3.start();
        
        //主线程开启
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        secquence.lock();
        try {
            System.out.println("开始");
            a.signal();
        }finally {
            secquence.unlock();
        }
    }
    
    //多线程的顺序执行
    
    private static int loopNumber=5;
    //打印方法
    public void showInfo(String str,Condition current,Condition next) {
        for(int i=0;i<loopNumber;i++) {
            lock();
            try {
                
                current.await();
                System.out.print(str);
                next.signal();
                
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                // TODO: handle exception
                unlock();
            }
        }
        
    }
    
}

1，同步锁原理

2，线程的状态图

2.1无限等待状态的图示

public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建唯一锁对象
        Object obj=new Object();
        
        //创建一个消费者线程
        new Thread() {
            @Override
            public void run() {
                //也一直等着吃
                while(true) {
                    //保证等待和唤醒只能有一个执行，
                    synchronized (obj) {
                        System.out.println("告诉老板要的包子的种类和数量");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        //唤醒之后的代码
                        System.out.println("包子做好了，开饭了");
                        System.out.println("-----------------------");
                    }
                }
            }
            
        }.start();
        
        //创建一个老板线程（生产者）
        new Thread() {
            @Override
            public void run() {
                //一直在这做
                while(true) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        System.out.println("老板5秒之后做好包子，告知顾客可以吃 包子");
                        obj.notify();
                    }
                }
            }
        }.start();
    }
    
}

等待与唤醒机制，线程间的通信 

代码实现:

package BaoZi;

public class Baozi {
    //皮
    String pi;
    //馅
    String xian;
    //状态
    boolean flag=false;
}

package BaoZi;

//注意使用同步技术，互斥
//必须使用同一个锁对象，并且将包子对象作为参数进行传递

public class BaoZiPu extends Thread {
    //包子变量
    private Baozi bz;
    
    //使用带参的构造方法，为包子变量赋值
    public BaoZiPu(Baozi bz) {
        this.bz=bz;
    }
    
    //设置线程任务（run）生产包子
    @Override
    public void run() {
        int count=0;//用于不同的馅的产生
        //使用同步机制
        while(true) {//一直生产包子
            synchronized (bz) {
                if(bz.flag==true) {
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                //被唤醒之后，生产包子
                if(count%2==0) {
                    //生产薄皮 三鲜馅
                    bz.pi="薄皮";
                    bz.xian="三鲜馅";
                }else {
                    bz.pi="冰皮";
                    bz.xian="牛肉大葱";
                }
                count++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
                //生产包子要3秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //包子铺生产好了，修改状态
                bz.flag=true;
                bz.notify();//唤醒等待的吃货线程
                System.out.println("包子铺已经生产："+bz.pi+bz.xian+"包子好了，您可以吃了");
            }
        }
        
    }

}

package BaoZi;

public class ChiHuo extends Thread{
    //包子变量
        private Baozi bz;
        
        //使用带参的构造方法，为包子变量赋值
        public ChiHuo(Baozi bz) {
            this.bz=bz;
        }
        
    
    @Override
    public void run() {
        //使用死循环一直吃
        while(true) {
            synchronized (bz) {
                if(bz.flag==false) {
                    //没有包子
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                //被唤醒之后执行的代码
                System.out.println("吃货正在吃"+bz.pi+bz.xian+"的包子");
                bz.flag=false;
                bz.notify();//唤醒包子铺
                System.out.println("吃货已经吃完了："+bz.pi+bz.xian+"的包子");
                System.out.println("-------------------");
            }
        }
    }

}

package BaoZi;



public class Test {
    public static void main(String[] args) {
        //创建包子对象
        Baozi bz=new Baozi();
        new BaoZiPu(bz).start();//创建包子铺线程
        new ChiHuo(bz).start();//创建吃货线程
    }
}

 五，线程池

1，自定义线程池

package ThreadPool;
//线程池

import java.util.HashSet;
import java.util.concurrent.TimeUnit;

public class TeadPool {
    //任务队列
 private BlockingQueue<Runnable> taskQueue;
 //核心线程
 private int coreSize;
 //线程集合，存放任务
 private HashSet<Worker> workers=new HashSet<TeadPool.Worker>();
 //获取任务的超时时间，以及单位
 private long timeout;
 private TimeUnit timeUnit;
     //拒绝策略
 RejectPolicy<Runnable> rejectPolicy;
 public TeadPool( int coreSize ,long timeout,TimeUnit timeUnit,int queueSize,RejectPolicy<Runnable> rejectPolicy) {
    
    taskQueue=new BlockingQueue<Runnable>(queueSize);
    this.coreSize = coreSize;
    
    this.timeout = timeout;
    this.timeUnit = timeUnit;
    this.rejectPolicy=rejectPolicy;
}

 //执行任务
 public void execute(Runnable task) {//要加锁
     synchronized (workers) {
        //小于交给worker执行
         //if线程集合中的任务数大于核心线程数，放入阻塞队列
         if(workers.size()<coreSize) {
             Worker worker=new Worker(task);
             workers.add(worker);
             worker.start();
         }else {
             //使用策略模式，处理情况拒绝策略，将决策权交给线程池的使用者
             //抽象成接口，实现是有调用者实现
            //掉用策略的逻辑放在blockingquqeue
             taskQueue.tryPut(rejectPolicy,task);
         }
    }
     
 }
 
//处理任务的类
 class Worker extends Thread{
     private Runnable task;
     
     public Worker(Runnable task) {
        
        this.task = task;
    }

    @Override
     
        public void run() {
            //执行任务
            //task不为空，执行任务
            //task执行完毕，去阻塞队列里取
            while(task!=null||(task=taskQueue.take())!=null) {
                try {
                    task.run();
                } catch (Exception e) {
                    // TODO: handle exception
                }finally {
                    task=null;//执行完任务
                }
                
            }
            synchronized (workers) {
                workers.remove(this);//没有任务要执行，移除
            }
        }
    
 }
}

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BlockingQueue<T> {
    //任务队列
    private Deque<T> queue=new ArrayDeque<T>();
    //锁
    ReentrantLock lock=new ReentrantLock();
    //容量
    private int capcity;
    //生产者等待条件变量
    private Condition fullWaitSet= lock.newCondition();
    //消费者等待条件变量
    private Condition emptyWaitSet=lock.newCondition();
    
    public BlockingQueue(int size) {
    this.capcity=size;
        // TODO Auto-generated constructor stub
    }
    //阻塞获取
    public T take() {//要加速操作
        lock.lock();
        try {
            
            while(queue.isEmpty()) {
                    //为空
                    try {
                        emptyWaitSet.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                    //不为空
                T t=queue.removeFirst();//要移除
                    //获取后唤醒 full
                    fullWaitSet.signal();
                    return t;
                
            
            
        } finally {
            // TODO: handle exception
            lock.unlock();
        }
        
    }
    //超时时间阻塞获取
        public T offer(long timeout,TimeUnit timeUnit) {//要加速操作
            lock.lock();
            
            try {
                long nanos=timeUnit.toNanos(timeout);
                while(queue.isEmpty()) {
                        //为空
                        try {
                            if(nanos<=0) {
                                return null;
                            }
                            nanos=emptyWaitSet.awaitNanos(nanos);//该方法会返回等待的剩余时间
                            
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                        //不为空
                    T t=queue.removeFirst();//要移除
                        //获取后唤醒 full
                        fullWaitSet.signal();
                        return t;
                    
                
                
            } finally {
                // TODO: handle exception
                lock.unlock();
            }
            
        }
    //阻塞添加
    public void put(T t) {
        lock.lock();
        try {
            while(queue.size()==capcity) {
                try {
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //队列有剩余空间
            queue.addLast(t);
            //唤醒 空
            emptyWaitSet.signal();
            
        } finally {
            // TODO: handle finally clause
            lock.unlock();
        }
    }
    //阻塞添加的超时时间
        public boolean poll(T t,long timeout,TimeUnit timeUnit) {
            lock.lock();
            try {
                long nanos=timeUnit.toNanos(timeout);
                while(queue.size()==capcity) {
                    try {
                        if(nanos<=0) {
                            return false;
                        }
                        nanos=fullWaitSet.awaitNanos(nanos);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //队列有剩余空间
                queue.addLast(t);
                //唤醒 空
                emptyWaitSet.signal();
                return true;
            } finally {
                // TODO: handle finally clause
                lock.unlock();
            }
        }
    //获取大小
    public int getCapcity() {//也要枷锁
        lock.lock();
        try {
            return this.capcity;
        } finally {
            // TODO: handle finally clause
            lock.unlock();
        }
        
    }
    public void tryPut(RejectPolicy<T> rejectPolicy,T task) {
        // TODO Auto-generated method stub
        lock.lock();
        try {
            //任务队列满了
            if(queue.size()==capcity) {
                //拒绝策略实现
                rejectPolicy.reject(this, task);
            }else {
                //队列有剩余空间
                queue.addLast(task);
                //唤醒 空
                emptyWaitSet.signal();
            }
        } finally {
            // TODO: handle finally clause
            lock.unlock();
        }
    }
}

//拒绝策略
public interface RejectPolicy<T> {
    void reject(BlockingQueue<T> queue,T task);
}

2，reentrantLock的tryAcquire的源码分析

原文链接：https://blog.csdn.net/sscout/article/details/102616722