「java多线程批处理」Java 多线程编程

博主:adminadmin 2022-12-19 18:15:07 90

今天给各位分享java多线程批处理的知识,其中也会对Java 多线程编程进行解释,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!

本文目录一览:

java多线程详细理解?

多线程:指的是这个程序(一个进程)运行时产生了不止一个线程

并行与并发:

并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。

并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力。

线程安全:经常用来描绘一段代码。指在并发的情况之下,该代码经过多线程使用,线程的调度顺序不影响任何结果。这个时候使用多线程,我们只需要关注系统的内存,cpu是不是够用即可。反过来,线程不安全就意味着线程的调度顺序会影响最终结果,如不加事务的转账代码:

请点击输入图片描述

同步:Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时,提高性能,才是优秀的程序。线程安全的优先级高于性能。

java多线程处理大批文件

线程数量一般是个估算值。这个要凭经验来判定。

判定规则如下:

如果您能保证您的线程程序不会因为等待任何I/O事件产生等待(比如等待网络、等待数据库、等待磁盘),那么应创建CPU进程个数个线程数。

如果您的线程程序I/O等待时间和执行时间大致相等,应创建CPU进程数x2个线程数。

java多线程更新数据库批量的数据信息吗?怎么实现?

//将数据库中的数据条数分段

public void division(){

//获取要导入的总的数据条数

String sql3="SELECT count(*) FROM [CMD].[dbo].[mycopy1]";

try {

pss=cons.prepareStatement(sql3);

rss=pss.executeQuery();

while(rss.next()){

System.out.println("总记录条数:"+rss.getInt(1));

sum=rss.getInt(1);

}

//每30000条记录作为一个分割点

if(sum=30000){

n=sum/30000;

residue=sum%30000;

}else{

residue=sum;

}

System.out.println(n+" "+residue);

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

线程类

public MyThread(int start,int end) {

this.end=end;

this.start=start;

System.out.println("处理掉余数");

try {

System.out.println("--------"+Thread.currentThread().getName()+"------------");

Class.forName(SQLSERVERDRIVER);

System.out.println("加载sqlserver驱动...");

cons = DriverManager.getConnection(CONTENTS,UNS,UPS);

stas = cons.createStatement();

System.out.println("连接SQLServer数据库成功!!");

System.out.println("加载mysql驱动.....");

Class.forName(MYSQLDRIVER);

con = DriverManager.getConnection(CONTENT,UN,UP);

sta = con.createStatement();

// 关闭事务自动提交

con.setAutoCommit(false);

System.out.println("连接mysql数据库成功!!");

} catch (Exception e) {

e.printStackTrace();

}

// TODO Auto-generated constructor stub

}

public ArrayListMember getAll(){

Member member;

String sql1="select * from (select row_number() over (order by pmcode) as rowNum,*" +

" from [CMD].[dbo].[mycopy1]) as t where rowNum between "+start+" and "+end;

try {

System.out.println("正在获取数据...");

allmembers=new ArrayList();

rss=stas.executeQuery(sql1);

while(rss.next()){

member=new Member();

member.setAddress1(rss.getString("address1"));

member.setBnpoints(rss.getString("bnpoints"));

member.setDbno(rss.getString("dbno"));

member.setExpiry(rss.getString("expiry"));

member.setHispoints(rss.getString("hispoints"));

member.setKypoints(rss.getString("kypoints"));

member.setLevels(rss.getString("levels"));

member.setNames(rss.getString("names"));

member.setPmcode(rss.getString("pmcode"));

member.setRemark(rss.getString("remark"));

member.setSex(rss.getString("sex"));

member.setTelephone(rss.getString("telephone"));

member.setWxno(rss.getString("wxno"));

member.setPmdate(rss.getString("pmdate"));

allmembers.add(member);

// System.out.println(member.getNames());

}

System.out.println("成功获取sqlserver数据库数据!");

return allmembers;

} catch (SQLException e) {

// TODO Auto-generated catch block

System.out.println("获取sqlserver数据库数据发送异常!");

e.printStackTrace();

}

try {

rss.close();

stas.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public void inputAll(ArrayListMember allmembers){

System.out.println("开始向mysql中写入");

String sql2="insert into test.mycopy2 values (?,?,?,?,?,?,?,?,?,?,?,?,?,?)";

try {

ps=con.prepareStatement(sql2);

System.out.println("-------------------------等待写入数据条数: "+allmembers.size());

for(int i=0;iallmembers.size();i++){

ps.setString(1, allmembers.get(i).getPmcode());

ps.setString(2, allmembers.get(i).getNames());

//System.out.println(allmembers.get(i).getNames());

ps.setString(3, allmembers.get(i).getSex());

ps.setString(4, allmembers.get(i).getTelephone());

ps.setString(5, allmembers.get(i).getAddress1());

ps.setString(6, allmembers.get(i).getPmdate());

ps.setString(7, allmembers.get(i).getExpiry());

ps.setString(8, allmembers.get(i).getLevels());

ps.setString(9, allmembers.get(i).getDbno());

ps.setString(10, allmembers.get(i).getHispoints());

ps.setString(11, allmembers.get(i).getBnpoints());

ps.setString(12, allmembers.get(i).getKypoints());

ps.setString(13, allmembers.get(i).getWxno());

ps.setString(14, allmembers.get(i).getRemark());

//插入命令列表

//ps.addBatch();

ps.executeUpdate();

}

//ps.executeBatch();

con.commit();

ps.close();

con.close();

this.flag=false;

System.out.println(Thread.currentThread().getName()+"---OK");

} catch (SQLException e) {

// TODO Auto-generated catch block

System.out.println("向mysql中更新数据时发生异常!");

e.printStackTrace();

}

}

@Override

public void run() {

// TODO Auto-generated method stub

while(trueflag){

this.inputAll(getAll());

}

}

java 多线程是什么?一个处理器怎么同时处理多个程序

进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令,也包括了执行指令所需的系统资源,不同进程所占用的系统资源相对独立。所以进程是重量级的任务,它们之间的通信和转换都需要操作系统付出较大的开销。

线程是进程中的一个实体,是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源,但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务,它们之间的通信和转换只需要较小的系统开销。

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;i3;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

第二线程退出

至于一个处理器同时处理多个程序,其实不是同时运行多个程序的,简单的说,如果是单核的CPU,在运行多个程序的时候其实是每个程序轮流占用CPU的,只是每个程序占用的时间很短,所以我们人为的感觉是“同时”运行多个程序。

在Java 中多线程的实现方法有哪些,如何使用

1、 认识Thread和Runnable

Java中实现多线程有两种途径:继承Thread类或者实现Runnable接口。Runnable是接口,建议用接口的方式生成线程,因为接口可以实现多继承,况且Runnable只有一个run方法,很适合继承。在使用Thread的时候只需继承Thread,并且new一个实例出来,调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例,之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结:Thread和Runnable是实现java多线程的2种方式,runable是接口,thread是类,建议使用runable实现java多线程,不管如何,最终都需要通过thread.start()来使线程处于可运行状态。

2、 认识Thread的start和run

1) start:

用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到spu时间片,就开始执行run()方法,这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束,此线程随即终止。

2) run:

run()方法只是类的一个普通方法而已,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。

总结:调用start方法方可启动线程,而run方法只是thread的一个普通方法调用,还是在主线程里执行。

3、 线程状态说明

线程状态从大的方面来说,可归结为:初始状态、可运行状态、不可运行状态和消亡状态,具体可细分为上图所示7个状态,说明如下:

1) 线程的实现有两种方式,一是继承Thread类,二是实现Runnable接口,但不管怎样,当我们new了thread实例后,线程就进入了初始状态;

2) 当该对象调用了start()方法,就进入可运行状态;

3) 进入可运行状态后,当该对象被操作系统选中,获得CPU时间片就会进入运行状态;

4) 进入运行状态后case就比较多,大致有如下情形:

·run()方法或main()方法结束后,线程就进入终止状态;

·当线程调用了自身的sleep()方法或其他线程的join()方法,就会进入阻塞状态(该状态既停止当前线程,但并不释放所占有的资源)。当sleep()结束或join()结束后,该线程进入可运行状态,继续等待OS分配时间片;

·当线程刚进入可运行状态(注意,还没运行),发现将要调用的资源被锁牢(synchroniza,lock),将会立即进入锁池状态,等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记,这时它们处于队列状态,既先到先得),一旦线程获得锁标记后,就转入可运行状态,等待OS分配CPU时间片;

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源,与阻塞状态不同),进入这个状态后,是不能自动唤醒的,必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程,但我们由不能确定具体唤醒的是哪一个线程,也许我们需要唤醒的线程不能够被唤醒,因此在实际使用时,一般都用notifyAll()方法,唤醒有所线程),线程被唤醒后会进入锁池,等待获取锁标记。

·当线程调用stop方法,即可使线程进入消亡状态,但是由于stop方法是不安全的,不鼓励使用,大家可以通过run方法里的条件变通实现线程的stop。

java多线程批处理的介绍就聊到这里吧,感谢你花时间阅读本站内容,更多关于Java 多线程编程、java多线程批处理的信息别忘了在本站进行查找喔。

The End

发布于:2022-12-19,除非注明,否则均为首码项目网原创文章,转载请注明出处。