u011921490的专栏

package zhu;/*** * 目的： * 保证线程安全 加上synchronized(多线程操作的对象)锁 * 静态方法 synchronized 隐含的锁标识是类名.class * 以下同步其实是在相同时间间隔内同步 所有需要在一个线程执行前延迟几分钟，并没有正真的同步、 * 特点： * 同种对象的两种方法加相同的锁  两个线程执行相应的方法  使多线程安全

import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/* *  两个线程执行生产 *  两线程执行消费 *  依次交替循环 * lock的方法(类的方法) 针对多

package zhu;/** * 需求： * 为保证同一个线程调用的函数所使用的资源相同 *     也就是 线程独享自己的数据 比如：银行转账 同一线程内共享连接，不同线程独立连接 *方案： * 使用map集合封装 线程的变量 和 线程对应的名字  * 可以使用ThreadLocal类解决 */import java.util.HashMap;i

package zhu.suo;import java.util.concurrent.ArrayBlockingQueue;/** * 子线程循环10次，接着主线程循环20次，接着又回到子线程循环10次，主线程循环20次，依次交替循环5次 * 使用阻塞队列:ArrayBlockingQueue类   方法 put(e) take() 若不满足条件则线程阻塞 *

package zhu;/*** * 目的： * 保证线程安全 加上synchronized(多线程操作的对象)锁 * 对方法枷锁 锁的标识就是this * 以下同步其实是在相同时间间隔内同步 所有需要在一个线程执行前延迟几分钟，并没有正真的同步 * 特点： * 同种对象的两种方法加相同的锁  两个线程执行相应的方法  使多线程安全 * */public c

package zhu;/* * 要求： * 利用Thread的局部变量类ThreadLocal 封装数据 * 然后再赋值数据 实现一个线程有多分相同的变量，而且各线程之间的变量值互不影响 * 官方应用场景: * 在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共享变量进行操作。 * 这种情况下

package zhu.ThreadPools;import java.util.Random;import java.util.concurrent.Callable;import java.util.concurrent.CompletionService;import java.util.concurrent.ExecutionException;import j

package zhu.suo;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;import java.util.concurrent.CopyOnWriteArrayList;/* * 在一般的集合遍历中 增删集合会报错 * 除非使用java5 封装的并发库集合 ...

package zhu.suo;import java.util.HashMap;import java.util.Map;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.

package zhu.suo;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/* * 要求：1，2，3兄弟，1循环5次，2循环10次，3循环15次

package zhu.suo;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/* * java5lock代替传统的synchronized * */public class LockTest {public static vo

package zhu.test;/** * 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，主线程循环100次，依次交替循环 * 50次 *  * @author nn *思想： * 把互斥资源封装到一个类中 */public class LoopTest {public static void main(String[] a

package zhu.test;/** * 需求： * 使同一份数据分别进行 加1 减1 交替出现 10次 * @author nn * */public class ThreadShareDataDemo1 {public static void main(String[] args) {final ShareDATA DataObj= new Sh

package zhu.test;/** * 方法一：包装类的使用 * 要求： 在jdk5之后出现线程安全类 比如AtomicInteger,...AtomicIntegerFieldUpdater   ,使用此类保证资源的互斥性 */import java.util.concurrent.atomic.*;  class Container {    publ

前言Java 锁也分很多中。。但这里介绍synchronize和lock区别1、synchronzie是基于jvm层面，lock是基于代码 2、synchronize块中出现异常jvm会直接释放锁，而lock出现异常必须在finally块中释放锁 3、少量进程之间的并发使用synchronize效率高，由于lock伸缩性比较强，处理大量并发效果好！

public class Test {public static void main(String[] args) {String a = "2"+"1";String b = "2"+"1";//在编译前  优化为"12"System.out.println(("2"+"1")==("2"+"1"));System.out.println(a==b);System

package zhu.suo;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class CondotionDemo {pub

package zhu.suo;import java.util.Random;import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;import java.util.concurrent.ExecutorService;import ja

package zhu.suo;/* * 2.十个线程乱序执行一个打印，每个打印需要一秒 * */import java.util.concurrent.Semaphore;import java.util.concurrent.SynchronousQueue;public class Test2 {public static void main(St

package zhu.suo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Semaphore;import java.util.concurrent.locks.ReentrantLock;

package zhu.suo;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;/*1.四个线程共用4秒打印出16条日志 *  * 解析： * 在print方法中 * 第一秒 四个进程同时带一个数据进入 * 同样。。 * */

package zhu.test;/** * 需求： * 使同一份数据分别进行 加1 减1 交替出现 10次 * @author nn * */public class ThreadShareDataDemo1 {public static void main(String[] args) {final ShareDATA DataObj= new Sh

package zhu.suo;import java.util.concurrent.CountDownLatch;import java.util.concurrent.CyclicBarrier;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/*

package zhu.suo;import java.util.concurrent.Exchanger;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/* * 两线程之间数据的交换 * */public class ExchangerDemo

package zhu.suo;/* * 3.输入 1,2       2,3       2,5       3,4输出      1,2--时间1     2，3--时间1     3，4--时间1     2，5--时间2四个线程同时执行//注意点： * 在System.currentMilions/1000获取时间中 出现 *

package zhu;/*** * 目的： * 保证线程安全 加上synchronized(多线程操作的对象)锁 * 特点： * 同种对象的一种方法， 用多个线程执行 给方法枷锁 * @author nn * */public class TraditionalThreadSynchronized2 {public static void main

package zhu;/*** * 目的： * 为了演示多线程不安全问题 * 出现打印不完全现象 * @author nn * */public class TraditionalThreadSynchronized {public static void main(String[] args) {new TraditionalThreadSync

package zhu.test;/** * 需求： * 使同一份数据分别进行 加1 减1 交替出现 10次 * 方法二 * 要求： 在jdk5之后出现线程安全类 比如AtomicInteger,...AtomicIntegerFieldUpdater   ,使用此类保证资源的互斥性 */import java.util.concurrent.atomic.*;  

package zhu.ThreadPools;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class Demo1 {public static v

package zhu;import java.util.Date;import java.util.Timer;import java.util.TimerTask;/** *  * 连环炸弹  * 需求： * 分别每隔 2 秒 、3 秒循环交替爆炸 * 特点： * 不使用循环语句，使用递归可以完成任务的交替循环 * @author n

package zhu.test;/** * 需求： * 使同一份数据分别进行 加1 减1 交替出现 10次 * @author nn * */public class CopyOfThreadShareDataDemo2 {static int data=0;public static void main(String[] args) {Data data