==========================================【1】===============================================
package com.xixue.entity;
/**
* 用戶實例
* @author houdo
*
*/
public class UserEntity {
/**
* 用戶id
*/
private String userId;
/**
* 用戶名稱
*/
private String userName;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public UserEntity(String userId, String userName) {
super();
this.userId = userId;
this.userName = userName;
}
@Override
public String toString() {
return "UserEntity [userId=" + userId + ", userName=" + userName + "]";
}
}
==========================================【2】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 常用線程API
* @author houdo
*
*/
public class ThreadDemoAPI {
private static Logger logger = Logger.getLogger(ThreadDemoAPI.class);
public static void main(String[] args) {
DemoThread demoThread = new DemoThread();
demoThread.start();
}
}
class DemoThread extends Thread{
private static Logger logger = Logger.getLogger(DemoThread.class);
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(getName()+"--------"+currentThread().getId());
}
}
}
==========================================【3】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 線程之間通信
*
* @author houdo
*
*/
public class ThreadDemoCommunication {
Logger logger = Logger.getLogger(ThreadDemoCommunication.class);
public static void main(String[] args) {
Resource resource = new Resource();
TreadProduce produce = new TreadProduce(resource);
ThreadConsumer consumer = new ThreadConsumer(resource);
produce.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
consumer.start();
}
}
/**
* 操作對象
*
* @author houdo
*
*/
class Resource {
private String name;
private String sex;
//線程通訊標識
public boolean flag = false;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Resource [name=" + name + ", sex=" + sex + "]";
}
}
/**
* 生產者
*
* @author houdo
*
*/
class TreadProduce extends Thread {
Logger logger = Logger.getLogger(TreadProduce.class);
Resource resource;
public TreadProduce(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
int num = 0;
while (true) {
synchronized (resource) {
if (resource.flag) {
try {
// 當前線程變爲等待，但是可以釋放鎖
resource.wait();
} catch (Exception e) {
}
}
if (num == 0) {
resource.setName("小紅");
resource.setSex("女");
} else {
resource.setName("小明");
resource.setSex("男");
}
num = (num + 1) % 2;
resource.flag = true;
// 喚醒當前線程
resource.notify();
}
}
}
}
/**
* 消費者
*
* @author houdo
*
*/
class ThreadConsumer extends Thread{
Logger logger = Logger.getLogger(ThreadConsumer.class);
Resource resource;
public ThreadConsumer(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
while (true) {
synchronized (resource) {
if (!resource.flag) {
try {
resource.wait();
} catch (Exception e) {
}
}
logger.info(resource.toString());
resource.flag = false;
resource.notify();
}
}
}
}
==========================================【4】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 線程死鎖
* @author houdo
*
*/
public class ThreadDemoDead {
public static void main(String[] args) throws InterruptedException {
DeadThread threadTrain = new DeadThread();
Thread thread = new Thread(threadTrain, "t1");
Thread thread2 = new Thread(threadTrain, "t2");
thread.start();
Thread.sleep(10000);
threadTrain.flag = false;
thread2.start();
}
}
class DeadThread implements Runnable {
Logger logger = Logger.getLogger(DeadThread.class);
private int count = 100;
Object obj1 = new Object();
Object obj2 = new Object();
public boolean flag = true;
@Override
public void run() {
if (flag) {
while (count > 0) {
synchronized (obj1) {
show();
}
}
} else {
while (count > 0) {
synchronized (obj2) {
show2();
}
}
}
}
public void show2() {
synchronized (obj1) {
logger.info("------------------");
if (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
}
public void show() {
synchronized (obj2) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
}
}
==========================================【5】===============================================
package com.xixue.process;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
/**
* 併發包 newCachedThreadPool newFixedThreadPool newScheduleThreadPool
* newSingleThreadExecutors
*
* @author houdo
*
*/
public class ThreadDemoExecutors {
@Test
private void test01() {
ExecutorService pool = Executors.newCachedThreadPool(); //具有緩存線程
for (int i = 0; i < 10; i++) {
int index = i;
pool.execute(new Runnable() {
@Override
public void run() {
try {
/*Thread.sleep(400);*/
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread() + "----" + index);
/*if (index == 9) {
newCachedThreadPool.shutdown();
}*/
}
});
}
}
@Test
private void test02() {
ExecutorService pool = Executors.newFixedThreadPool(2); //每次執行固定的線程個數
for (int i = 0; i < 10; i++) {
int index = i;
pool.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(400);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread() + "----" + index);
/*if (index == 9) {
newCachedThreadPool.shutdown();
}*/
}
});
}
}
@Test
private void test03() {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(5); //定時的線程池
pool.schedule(new Runnable() {
public void run() {
System.out.println("三秒之後執行");
}}, 3, TimeUnit.SECONDS);
}
public static void main(String[] args) {
// ExecutorService pool = Executors.newCachedThreadPool(); //具有緩存線程
// ExecutorService pool = Executors.newFixedThreadPool(2); //每次執行固定的線程個數
// ScheduledExecutorService pool = Executors.newScheduledThreadPool(5); //定時的線程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); //單線程池
for (int i = 0; i < 10; i++) {
int index = i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(400);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread() + "----" + index);
/*if (index == 9) {
newCachedThreadPool.shutdown();
}*/
}
});
}
}
}
==========================================【6】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* java內存模型 JMM 共享全局變量 + 線程本地變量
* @author houdo
*
*/
public class ThreadDemoJMM {
static Logger logger = Logger.getLogger(ThreadDemoJMM.class);
public static void main(String[] args) throws InterruptedException {
DemoJMM demoJMM = new DemoJMM();
demoJMM.start();
Thread.sleep(100);
demoJMM.getRun(false);
}
}
class DemoJMM extends Thread{
public volatile boolean flag = true;
@Override
public void run() {
System.out.println("子線程開始執行");
while (flag) {
}
System.out.println("子線程結束");
}
public void getRun(boolean flag){
this.flag = flag;
}
}
==========================================【7】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 線程join方法
* @author houdo
*
*/
public class ThreadDemoJoin {
static Logger logger = Logger.getLogger(ThreadDemoJoin.class);
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for(int i =0 ; i < 100 ; i++) {
logger.info(Thread.currentThread().getName()+"--"+i);
}
}
},"t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for(int i =0 ; i < 100 ; i++) {
logger.info(Thread.currentThread().getName()+"--"+i);
}
}
},"t2");
t1.start();
t1.join();
t2.start();
for(int i =0 ; i < 100 ; i++) {
logger.info(Thread.currentThread().getName()+"--"+i);
}
}
}
==========================================【8】===============================================
package com.xixue.process;
import com.xixue.BaseFunction;
/**
* 匿名內部類
* @author houdo
*
*/
public class ThreadDemoNON {
private static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(ThreadDemoNON.class);
public static void main(String[] args) {
logger.info("創建線程開始");
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
if (i==199) {
System.out.println(10/0);
}
logger.info("run"+i);
}
}
}).start();
logger.info("創建線程結束");
for (int i = 0; i < 200; i++) {
logger.info("run"+i);
}
}
}
==========================================【9】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 實現Runable接口
* @author houdo
*
*/
public class ThreadDemoRunable {
private static Logger logger = Logger.getLogger(ThreadDemoRunable.class);
public static void main(String[] args) {
logger.info("創建線程開始");
CreateRunable createRunable = new CreateRunable();
Thread thread = new Thread(createRunable);
thread.start();
logger.info("創建線程結束");
for (int i = 0; i < 200; i++) {
logger.info("run"+i);
}
}
}
class CreateRunable implements Runnable{
private Logger logger = Logger.getLogger(CreateRunable.class);
@Override
public void run() {
for (int i = 0; i < 200; i++) {
if (i==199) {
System.out.println(10/0);
}
logger.info("run"+i);
}
}
}
==========================================【10】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 線程同步
* @author houdo
*
*/
public class ThreadDemoSync {
public static void main(String[] args) {
ProveSynchronizedByThis threadTrain = new ProveSynchronizedByThis();
Thread thread = new Thread(threadTrain, "t1");
Thread thread2 = new Thread(threadTrain, "t2");
thread.start();
try {
Thread.sleep(50);
} catch (InterruptedException e) {
}
threadTrain.flag = false;
thread2.start();
}
}
/**
* 證明同步方法相當於同步代碼塊this
*
* @author houdo
*
*/
class ProveSynchronizedByThis implements Runnable {
Logger logger = Logger.getLogger(ProveSynchronizedByThis.class);
private int count = 100;
private Object obj = new Object();
public boolean flag = true;
public synchronized void show() {
if (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
@Override
public void run() {
if (flag) {
while (count > 0) {
synchronized (this) {
if (count > 0) {
try {
Thread.sleep(40);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
}
} else {
while (count > 0) {
show();
}
}
}
}
/**
* 同步代碼塊synchronized
*
* @author houdo
*
*/
class ThreadTrain implements Runnable {
Logger logger = Logger.getLogger(ThreadTrain.class);
private int count = 100;
private Object obj = new Object();
@Override
public void run() {
while (count > 0) {
synchronized (obj) {
if (count > 0) {
try {
Thread.sleep(40);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
}
}
}
/**
* 同步方法synchronized
*
* @author houdo
*
*/
class ThreadTrain2 implements Runnable {
Logger logger = Logger.getLogger(ThreadTrain2.class);
private int count = 100;
private Object obj = new Object();
@Override
public void run() {
while (count > 0) {
show();
}
}
public synchronized void show() {
if (count > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
logger.error(e);
}
logger.info(Thread.currentThread().getName() + "[" + (100 - count + 1) + "]");
count--;
}
}
}
==========================================【11】===============================================
package com.xixue.process;
/**
* ThreadLocal
*
* @author houdo
*
*/
public class ThreadDemoThreadLocal {
public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
@Override
protected java.lang.Integer initialValue() {
// TODO Auto-generated method stub
return 0;
}
};
public static void main(String[] args) {
Thread[] threads = new Thread[5];
for (Thread thread : threads) {
thread =new Thread(new Runnable() {
@Override
public void run() {
Integer integer = threadLocal.get();
integer +=5;
System.out.println(Thread.currentThread().getName() + "---" + integer);
}
});
thread.start();
}
}
}
class DemoThreadLocal {
}
==========================================【12】===============================================
package com.xixue.process;
import org.apache.log4j.Logger;
/**
* 繼承Thread
* @author houdo
* 創建線程
*/
public class ThreadDemoThreads {
private static Logger logger = Logger.getLogger(ThreadDemoThreads.class);
private static String flag="";
public static void main(String[] args) {
logger.info("開始創建線程");
CreateThread createThread = new CreateThread();
createThread.setName("slave");
createThread.start();
// createThread.run();
logger.info("線程已經開始執行");
for (int i = 0; i < 200; i++) {
logger.info("main"+i);
}
}
}
class CreateThread extends Thread{
private Logger logger = Logger.getLogger(CreateThread.class);
@Override
public void run() {
for (int i = 0; i < 200; i++) {
if (i==199) {
System.out.println(10/0);
}
logger.info("run"+i);
}
}
}
==========================================【13】===============================================
package com.xixue.sendSMS;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import com.xixue.entity.UserEntity;
import com.xixue.process.ThreadDemoRunable;
class UserThread extends Thread{
private static Logger logger = Logger.getLogger(UserThread.class);
private List<UserEntity> listUser;
public UserThread(List<UserEntity> list) {
this.listUser = list;
}
@Override
public void run() {
for (UserEntity userEntity : listUser) {
logger.info("["+getName()+"]"+userEntity.toString());
}
}
}
/**
* 批量發送短信
* @author houdo
*
*/
public class BantchSendSMS {
private static Logger logger = Logger.getLogger(BantchSendSMS.class);
public static void main(String[] args) {
//初始化用戶
List<UserEntity> setUserList = setUserList(10000000);
//計算線程數
List<List<UserEntity>> splitList = splitList(setUserList, 10000);
//開始進行異步處理數據
for (List<UserEntity> list : splitList) {
UserThread thread = new UserThread(list);
thread.start();
}
}
/**
* 創建用戶
* @return
*/
public static List<UserEntity> setUserList(int num) {
List<UserEntity> listUser = new ArrayList<>();
for (int i = 0; i < num; i++) {
listUser.add(new UserEntity("userId:"+i,"userName:"+i));
}
return listUser;
}
/**
* 功能描述:(list 集合分批切割)
* @param list
* @param pageSize 分頁長度
* @return
*/
static public <T> List<List<T>> splitList(List<T> list, int pageSize) {
int listSize = list.size();
int page = (listSize + (pageSize - 1)) / pageSize; //頁數
List<List<T>> listArray = new ArrayList<List<T>>();
for (int i = 0; i < page; i++) {
List<T> subList = new ArrayList<T>();
for (int j = 0; j < listSize; j++) {
int pageIndex = ((j + 1) + (pageSize - 1)) / pageSize;
if (pageIndex == (i + 1)) {
subList.add(list.get(j));
}
if ((j + 1) == ((j + 1) * pageSize)) {
break;
}
}
listArray.add(subList);
}
logger.info("切割完成");
return listArray;
}