java 多线程
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java 多线程相关的知识，希望对你有一定的参考价值。
当启动线程时。读取aa表中的数据。得到字段bb 的值。如果bb = 1条件满足。就执行任务，如果有多条数据满足这个条件。一条数据要新建一个线程来执行任务。有多少条数据就要开启多少条线程。该如何做。如何根据事件来停止线程。
所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。
Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。
Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。
class ThreadTest
public static void main(String args[])
Thread t = Thread.currentThread();
t.setName("单线程"); //对线程取名为"单线程"
t.setPriority(8);
//设置线程优先级为8，最高为10，最低为1，默认为5
System.out.println("The running thread: " + t);
// 显示线程信息
try
for(int i=0;i<3;i++)
System.out.println("Sleep time " + i);
Thread.sleep(100); // 睡眠100毫秒
catch(InterruptedException e)// 捕获异常
System.out.println("thread has wrong");
多线程的实现方法
继承Thread类
可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。
在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
public class ThreadSubclassName extends Thread
public ThreadSubclassName()
..... // 编写子类的构造方法，可缺省
public void run()
..... // 编写自己的线程代码
用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:
ThreadSubclassName ThreadObject =
new ThreadSubclassName();
然后，就可启动该线程对象表示的线程：
ThreadObject.start(); //启动线程
应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。
class ThreadDemo extends Thread
private String whoami;
private int delay;
public ThreadDemo(String s,int d)
whoami=s;
delay=d;
public void run()
try
sleep(delay);
catch(InterruptedException e)
System.out.println("Hello World!" + whoami
+ " " + delay);
public class MultiThread
public static void main(String args[])
ThreadDemo t1,t2,t3;
t1 = new ThreadDemo("Thread1",
(int)(Math.random()*2000));
t2 = new ThreadDemo("Thread2",
(int)(Math.random()*2000));
t3 = new ThreadDemo("Thread3",
(int)(Math.random()*2000));
t1.start();
t2.start();
t3.start();
实现Runnable接口
编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。
创建线程对象可用下面的两个步骤来完成:
(1)生成Runnable类ClassName的对象
ClassName RunnableObject = new ClassName();
(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。
Thread ThreadObject = new Thread(RunnableObject);
然后，就可启动线程对象ThreadObject表示的线程：
ThreadObject.start();
在Thread类中带有Runnable接口的构造方法有:
public Thread(Runnable target);
public Thread(Runnable target, String name);
public Thread(String name);
public Thread(ThreadGroup group，Runnable target);
public Thread(ThreadGroup group，Runnable target，
String name);
其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。
用Runnable接口实现的多线程。
class TwoThread implements Runnable
TwoThread()
Thread t1 = Thread.currentThread();
t1.setName("第一主线程");
System.out.println("正在运行的线程: " + t1);
Thread t2 = new Thread(this,"第二线程");
System.out.println("创建第二线程");
t2.start();
try
System.out.println("第一线程休眠");
Thread.sleep(3000);
catch(InterruptedException e)
System.out.println("第一线程有错");
System.out.println("第一线程退出");
public void run()
try
for(int i = 0;i < 5;i++)
System.out.println(“第二线程的休眠时间：”
+ i);
Thread.sleep(1000);
catch(InterruptedException e)
System.out.println("线程有错");
System.out.println("第二线程退出");
public static void main(String args[])
new TwoThread();
程序运行结果如下：
正在运行的线程: Thread[第一主线程,5,main
创建第二线程
第一线程休眠
第二线程的休眠时间：0
第二线程的休眠时间：1
第二线程的休眠时间：2
第一线程退出
第二线程的休眠时间：3
第二线程的休眠时间：4
第二线程退出
另外,团IDC网上有许多产品团购,便宜有口碑 参考技术A int c;
s首先用select c=count(*) from aa where bb=1 得到满足条件数据的个数
然后就定义c个线程
最后停止，就是在run（）
后加一个条件判定的destory（）追问
能不能写个详细的例子
追答已尽力了，你自己也要看看语法啊。在上班，没时间的问楼上
参考技术B 在线程的run方法里面读取表数据，然后用for循环进行判断，符合条件就开启一个线程，你要根据事件太停止线程，这个也得判断啊 具体什么条件 这要根据情况而定追问能不能写个详细的例子
追答int num=0;
num= select count(*) from aa where bb=1
for(int i=0;i<num;i++)
//new 个线程 然后调用start方法
//具体的停止线程 要在线程里面根据判断条件 执行destory方法
在重写run()方法中写
int num=0;
num= select count(*) from aa where bb=1
for(int i=0;i<num;i++)
//new 个线程 然后调用start方法，
//我不知道这里new 个线程是如何走向的。条件满足了才执行任务。这个任务放在哪个位置
你单独写个线程的类 在run方法里写上你要处理的业务啊 ，
class Thread1 extends Thread
public void run()
//根据判断条件执行destory方法啊
Java多线程 5.栅栏
5.1 ReadMe
此文线程和任务可以理解为一个意思；
Java中一般通过CountDownLantch和CyclicBarrier来解决线程（任务）之间依赖的问题，栅栏特指CyclicBarrier类，因为CountDownLatch可以实现类似功能，所以在此放到一块讲解；
在任务A依赖任务B的这种场景可以使用Object的wait和notify来实现，但是如果任务A依赖任务B、C、D多个任务的场景，使用Object的wait和notify就难以实现，例如运动会10个人长跑（看作10个长跑任务），公布总排名这个任务就依赖至少9个长跑任务结束，这种场景适合使用CountDownLatch；
结合实际开发过程，更多的场景是A、B、C多个任务同时执行，但是A、B、C任务在执行过程中的某一个点相互依赖，例如一个需求分为前段开发和后端开发，前后端开始联调的时间点就是2个任务相互依赖的点，这种场景适合使用CyclicBarrier；
5.2 CountDownLatch
Latch是门闩的意思，要打开门需要打开门上的所有门闩，CountDownLatch可以理解为一个有多个门闩的门，每个门闩需要一个的线程打开；
代码实现举例：
1 import java.security.SecureRandom; 2 import java.util.concurrent.CountDownLatch; 3 import java.util.concurrent.ExecutorService; 4 import java.util.concurrent.Executors; 5 import java.util.concurrent.TimeUnit; 6 7 /** 8 * CountDownLatch实例 9 */ 10 public class DemoCountDownLatch { 11 12 //参赛人数 / 门闩个数 13 private static final int COUNT_RUNNER = 3; 14 15 public static void main(String[] args) throws Exception { 16 17 // 3人参加比赛 / 创建一个有3个门闩的门 18 CountDownLatch countDownLatch = new CountDownLatch(COUNT_RUNNER); 19 20 // 创建3人跑道 / 装上门 21 ExecutorService executorService = Executors.newFixedThreadPool(COUNT_RUNNER); 22 23 for (int i = 0; i < 3; i++) { 24 executorService.submit(new Runner("runner" + i, countDownLatch)); 25 } 26 27 // 等待3人跑到终点 / 把3个门闩都锁上 28 countDownLatch.await(); 29 30 // 公布3人成绩 / 打开门了 31 System.out.println("all runner game over."); 32 } 33 34 static class Runner implements Runnable { 35 36 private String name; 37 38 private CountDownLatch countDownLatch; 39 40 public Runner(String name, CountDownLatch countDownLatch) { 41 this.name = name; 42 this.countDownLatch = countDownLatch; 43 } 44 45 @Override 46 public void run() { 47 try { 48 SecureRandom secureRandom = SecureRandom.getInstanceStrong(); 49 int runTime = Math.abs(secureRandom.nextInt()) % 10; 50 TimeUnit.SECONDS.sleep(runTime); 51 System.out.println(this.name + " game over cost " + runTime + " second."); 52 } catch (Exception e) { 53 e.printStackTrace(); 54 } 55 56 // 跑到终点 / 打开门闩 57 this.countDownLatch.countDown(); 58 } 59 } 60 }
说明：
1. 一个CountDownLatch对象后只能使用一次，也就是说不能工作同一个CountDownLatch对象来重复控制线程的依赖问题;
2.上面的例子中如果有长跑运动员中途放弃比赛，是否永远不能公布总的比赛成绩？ CountDownLatch的await可以有入参（timeout, TimeUnit）表示最长等待时间;
5.3 CyclicBarrier
CyclicBarrier是循环栅栏的的意思，循环表示同一个CyclicBarrier可以重复使用（区别于CountDownLatch），Barrier栅栏可以理解为线程相互依赖的那个点（例如前后端联调时间点），各个线程在那个点相互等待，等所有线程到达点后才继续执行；
代码实现举例：
1 import java.time.Instant; 2 import java.util.concurrent.*; 3 4 /** 5 * 前端开发倩倩和后端开发厚厚开发一个需求 6 * 两人先独自开发需求，等都开发完再一块联调功能 7 */ 8 public class DemoCyclicBarrier 9 { 10 public static void main(String[] args) throws InterruptedException 11 { 12 13 // 创建栅栏，参数一为相互依赖的任务数；参数二为各任务到达依赖点后先执行的任务，等任务执行结束相互依赖的任务继续执行 14 CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> { 15 System.out.println("准备开始联调吧..."); 16 lastSecond(3L); 17 }); 18 19 // 创建线程池执行2个任务 20 ExecutorService executorService = Executors.newFixedThreadPool(2); 21 executorService.execute(new Coder(10L, "后端", cyclicBarrier)); 22 executorService.execute(new Coder(3L, "前端", cyclicBarrier)); 23 } 24 25 /** 26 * 线程持续second秒 27 */ 28 private static void lastSecond(long second) 29 { 30 Instant instant = Instant.now(); 31 while (Instant.now().minusSeconds(second).isBefore(instant)) 32 { 33 } 34 } 35 36 static class Coder implements Runnable 37 { 38 // 完成工作需要的时间 39 private long workTime; 40 41 private String name; 42 43 private CyclicBarrier cyclicBarrier; 44 45 public Coder(long workTime, String name, CyclicBarrier cyclicBarrier) 46 { 47 this.workTime = workTime; 48 this.name = name; 49 this.cyclicBarrier = cyclicBarrier; 50 } 51 52 @Override 53 public void run() 54 { 55 try 56 { 57 System.out.println(this.name + " are coding..."); 58 lastSecond(this.workTime); 59 System.out.println(this.name + " code end wait debugging.."); 60 // 完成工作/到达依赖的点/我这边可以开始联调了 61 this.cyclicBarrier.await(); 62 System.out.println("we are debugging.."); 63 64 } 65 catch (InterruptedException e) 66 { 67 // 当前线程被中断 68 e.printStackTrace(); 69 } 70 catch (BrokenBarrierException e) 71 { 72 // 1.其他线程中断；2.其他线程await方法超时；3.cyclicBarrier重置 73 e.printStackTrace(); 74 } 75 // catch (TimeoutException e) 76 // { 77 // //当前线程的await方法超时(await方法设置超时参数) 78 // e.printStackTrace(); 79 // } 80 } 81 } 82 }
说明：
1.CyclicBarrier作为循环栅栏，同一个对象可以循环使用；
2.上面例子中前端开发人员很短时间开发结束，通过await()一直在等待后端开发结束，可以通过await(timeout, TimeUnit)来设置最长等待时间；
3. 可以通过CyclicBarrier的getNumberWaiting()查看到达依赖点的任务；
4.CyclicBarrier构造方法的第二个参数指定的任务A，在其他相互依赖的任务到达依赖点后，任务A优先执行，并且是执行结束，其他任务才继续执行；
5.4 CyclicBarrier&CountDownLatch举例
1 import java.time.Instant; 2 import java.util.concurrent.*; 3 4 public class Demo_CyclicBarrier_CountDownLatch 5 { 6 private static final int COUNT_WORKER = 2; 7 8 public static void main(String[] args) throws InterruptedException 9 { 10 CountDownLatch countDownLatch = new CountDownLatch(COUNT_WORKER); 11 CyclicBarrier cyclicBarrier = new CyclicBarrier(COUNT_WORKER, () -> { 12 System.out.println("准备开始联调吧..."); 13 lastSecond(3L); 14 }); 15 16 ExecutorService executorService = Executors.newFixedThreadPool(2); 17 executorService.execute(new Coder(10L, "后端", countDownLatch, cyclicBarrier)); 18 executorService.execute(new Coder(3L, "前端", countDownLatch, cyclicBarrier)); 19 20 countDownLatch.await(); 21 System.out.println("开发联调结束，需求交付..."); 22 } 23 24 /** 25 * 线程持续second秒 26 */ 27 private static void lastSecond(long second) 28 { 29 Instant instant = Instant.now(); 30 while (Instant.now().minusSeconds(second).isBefore(instant)) 31 { 32 } 33 } 34 35 static class Coder implements Runnable 36 { 37 // 开发联调时间 38 private long workTime; 39 40 private String name; 41 42 private CountDownLatch countDownLatch; 43 44 private CyclicBarrier cyclicBarrier; 45 46 public Coder(long workTime, String name, CountDownLatch countDownLatch, CyclicBarrier cyclicBarrier) 47 { 48 this.workTime = workTime; 49 this.name = name; 50 this.countDownLatch = countDownLatch; 51 this.cyclicBarrier = cyclicBarrier; 52 } 53 54 @Override 55 public void run() 56 { 57 try 58 { 59 System.out.println(this.name + " are coding..."); 60 lastSecond(this.workTime); 61 System.out.println(this.name + " code end wait debugging.."); 62 63 this.cyclicBarrier.await(); 64 65 System.out.println(this.name + " are debugging.."); 66 lastSecond(this.workTime); 67 68 System.out.println(this.name + " debug end.."); 69 this.countDownLatch.countDown(); 70 } 71 catch (Exception e) 72 { 73 e.printStackTrace(); 74 } 75 } 76 } 77 }
以上是关于java 多线程的主要内容，如果未能解决你的问题，请参考以下文章