java多线程数据
可以用拍孝樱Scoket套接字让服务器和慎亩客户端袭丛建立连接
可以根据Scoket对象的getInputStream()和getOutputStream()获得输入输出流
再往流里面写信息
就实现了简单的数据传递
当然等待数据
的时候会有阻塞现象
所以使用线程来保证数据不会因为等待而阻塞
以mysql为数据库写的一个粗陋的demo，你参考一下，希望不会因为代码过多被网络吞了——
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
allotThread();
}
/**
* 将100条数据分成10份并启动10个线程分别操作
*/
public static void allotThread() {
List<String[]> datas = buildDatas();
for (int i=0; i<100; i+=10) {
List<String[]> tenDatas = datas.subList(i, i + 10);
insertData(tenDatas);
}
}
/**
* 创建100条模拟数据
* @return
*/
public static List<String[]> buildDatas() {
List<String[]> datas = new ArrayList<String[]>();
for (int i=0; i<100; i++) {
String[] data = {"id " + i, "name " + i};
datas.add(data);
}
return datas;
}
/**
* 启动线程进行数据插入操作
* @param tenDatas
*/
public static void insertData(final List<String[]> tenDatas) {
new Thread(new Runnable() {
public void run() {
String sql = "insert into testtable (id, name) values (?, ?)";
Connection conn = null;
PreparedStatement pstmt = null;
try {
conn = getConnection();
conn.setAutoCommit(false);
pstmt = getPstmt(conn, sql);
for (String[] data : tenDatas) {
pstmt.setString(1, data[0]);
pstmt.setString(2, data[1]);
pstmt.addBatch();
}
pstmt.executeBatch();
conn.commit();
conn.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
rollback(conn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
close(pstmt);
close(conn);
}
}
}).start();
}
public static Connection getConnection() throws SQLException, ClassNotFoundException {
Class.forName("com.mysql.jdbc.Driver");
String dbUrl = "jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=UTF-8";
Connection conn = DriverManager.getConnection(dbUrl, "root", "tooeasy");
return conn;
}
public static PreparedStatement getPstmt(Connection conn, String sql) throws SQLException, ClassNotFoundException {
PreparedStatement pstmt = conn.prepareStatement(sql);
return pstmt;
}
public static void rollback(Connection conn) {
try {
if (null != conn) {
conn.rollback();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(Connection conn) {
try {
if (null != conn) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(PreparedStatement pstmt) {
try {
if (null != pstmt) {
pstmt.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(ResultSet rs) {
try {
if (null != rs) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Ⅲ java 多线程操作数据库
//将数据库中的数据条数分段
publicvoiddivision(){
//获取要导入的总的数据条数
Stringsql3="SELECTcount(*)FROM[CMD].[dbo].[my1]";
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;
resie=sum%30000;
}else{
resie=sum;
}
System.out.println(n+""+resie);
}catch(SQLExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
线程类
publicMyThread(intstart,intend){
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(Exceptione){
e.printStackTrace();
}
//TODOAuto-generatedconstructorstub
}
publicArrayList<Member>getAll(){
Membermember;
Stringsql1="select*from(selectrow_number()over(orderbypmcode)asrowNum,*"+
"from[CMD].[dbo].[my1])astwhererowNumbetween"+start+"and"+end;
try{
System.out.println("正在获取数据...");
allmembers=newArrayList();
rss=stas.executeQuery(sql1);
while(rss.next()){
member=newMember();
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数据库数据！");
returnallmembers;
}catch(SQLExceptione){
//TODOAuto-generatedcatchblock
System.out.println("获取sqlserver数据库数据发送异常！");
e.printStackTrace();
}
try{
rss.close();
stas.close();
}catch(SQLExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
returnnull;
}
publicvoidinputAll(ArrayList<Member>allmembers){
System.out.println("开始向mysql中写入");
Stringsql2="insertintotest.my2values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
try{
ps=con.prepareStatement(sql2);
System.out.println("-------------------------等待写入数据条数:"+allmembers.size());
for(inti=0;i<allmembers.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(SQLExceptione){
//TODOAuto-generatedcatchblock
System.out.println("向mysql中更新数据时发生异常！");
e.printStackTrace();
}
}
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
while(true&&flag){
this.inputAll(getAll());
}
}
Ⅳ Java多线程程序设计初步入门
在Java语言产生前 传统的程序设计语言的程序同一时刻只能单任务操作 效率非常低 例如程序往往在接收数据输入时发生阻塞 只有等到程序获得数据后才能继续运行 随着Internet的迅猛发展 这种状况越来越不能让人们忍受 如果网络接收数据阻塞 后台程序就处于等待状态而不继续任何操作 而这种阻塞是经常会碰到的 此时CPU资源被白白的闲置起来 如果在后台程序中能够同时处理多个任务 该多好啊！应Internet技术而生的Java语言解决了这个问题 多线程程序是Java语言的一个很重要的特点 在一个Java程序中 我们可以同时并行运行多个相对独立的线程 例如 我们如果创建一个线程来进行数据输入输出 而创建另一个线程在后台进行其它的数据处理 如果输入输出线程在接收数据时阻塞 而处理数据的线程仍然在运行 多线程程序设计大大提高了程序执行效率和处理能力
线程的创建
我们知道Java是面向对象的程序语言 用Java进行程序设计就是设计和使用类 Java为我们提供了线程类Thread来创建线程 创建线程与创建普通闹梁的类的对象的操作是一样的 而线程就是Thread类或其子类的实例对象 下面是一个创建启动一个线程的语句
Thread thread =new Thread(); file://声明困弯神一个对象实例 即创建一个线程
Thread run(); file://用Thread类中的run()方法启动线程
从这个例子 我们可以通过Thread（）构造方法创建一个线程 并启动该线程 事实上 启动线程 也就是启动线程的run（）方法 而Thread类中的run（）方法没有任何操作语句 所以这个线程没有任何操作 要使线程实现预定功能 必须定义自己的run（）方法 Java中通常有两种方式定义run（）方法
通过定义一个Thread类的子类 在该子类中重写run（）方法 Thread子类的实例对象就是一个线程 显然 该线程汪亏有我们自己设计的线程体run（）方法 启动线程就启动了子类中重写的run（）方法
通过Runnable接口 在该接口中定义run（）方法的接口 所谓接口跟类非常类似 主要用来实现特殊功能 如复杂关系的多重继承功能 在此 我们定义一个实现Runnable（） 接口的类 在该类中定义自己的run（）方法 然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程
线程被实际创建后处于待命状态 激活（启动）线程就是启动线程的run（）方法 这是通过调用线程的start（）方法来实现的
下面一个例子实践了如何通过上述两种方法创建线程并启动它们
// 通过Thread类的子类创建的线程 class thread extends Thread { file://自定义线程的run()方法 public void run() { System out println( Thread is running… ); } } file://通过Runnable接口创建的另外一个线程 class thread implements Runnable { file://自定义线程的run()方法 public void run() { System out println( Thread is running… ); } } file://程序的主类 class Multi_Thread file://声明主类 { plubic static void mail(String args[]) file://声明主方法 { thread threadone=new thread (); file://用Thread类的子类创建线程 Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程 threadone start(); threado start(); file://strat()方法启动线程 } }
运行该程序就可以看出 线程threadone和threado交替占用CPU 处于并行运行状态 可以看出 启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类) 调用start()方法启动线程的run()方法不同于一般的调用方法 调用一般方法时 必须等到一般方法执行完毕才能够返回start()方法 而启动线程的run()方法后 start()告诉系统该线程准备就绪可以启动run()方法后 就返回start()方法执行调用start()方法语句下面的语句 这时run()方法可能还在运行 这样 线程的启动和运行并行进行 实现了多任务操作
线程的优先级
对于多线程程序 每个线程的重要程度是不尽相同 如多个线程在等待获得CPU时间时 往往我们需要优先级高的线程优先抢占到CPU时间得以执行 又如多个线程交替执行时 优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些 这样 高优先级的线程处理的任务效率就高一些
Java中线程的优先级从低到高以整数 ~ 表示 共分为 级 设置优先级是通过调用线程对象的setPriority()方法 如上例中 设置优先级的语句为
thread threadone=new thread (); file://用Thread类的子类创建线程
Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程
threadone setPriority( ); file://设置threadone的优先级
threado setPriority( ); file://设置threado的优先级
threadone start(); threado start(); file://strat()方法启动线程
这样 线程threadone将会优先于线程threado执行 并将占有更多的CPU时间 该例中 优先级设置放在线程启动前 也可以在启动后进行设置 以满足不同的优先级需求
线程的（同步）控制
一个Java程序的多线程之间可以共享数据 当线程以异步方式访问共享数据时 有时候是不安全的或者不和逻辑的 比如 同一时刻一个线程在读取数据 另外一个线程在处理数据 当处理数据的线程没有等到读取数据的线程读取完毕就去处理数据 必然得到错误的处理结果 这和我们前面提到的读取数据和处理数据并行多任务并不矛盾 这儿指的是处理数据的线程不能处理当前还没有读取结束的数据 但是可以处理其它的数据
如果我们采用多线程同步控制机制 等到第一个线程读取完数据 第二个线程才能处理该数据 就会避免错误 可见 线程同步是多线程编程的一个相当重要的技术
在讲线程的同步控制前我们需要交代如下概念
用Java关键字synchonized同步对共享数据操作的方法
在一个对象中 用synchonized声明的方法为同步方法 Java中有一个同步模型 监视器 负责管理线程对对象中的同步方法的访问 它的原理是 赋予该对象唯一一把 钥匙 当多个线程进入对象 只有取得该对象钥匙的线程才可以访问同步方法 其它线程在该对象中等待 直到该线程用wait（）方法放弃这把钥匙 其它等待的线程抢占该钥匙 抢占到钥匙的线程后才可得以执行 而没有取得钥匙的线程仍被阻塞在该对象中等待
file://声明同步的一种方式 将方法声明同步
class store {public synchonized void store_in(){… }public synchonized void store_out(){ … }}
利用wait（） notify（）及notifyAll（）方法发送消息实现线程间的相互联系
Java程序中多个线程通过消息来实现互动联系的 这几种方法实现了线程间的消息发送 例如定义一个对象的synchonized 方法 同一时刻只能够有一个线程访问该对象中的同步方法 其它线程被阻塞 通常可以用notify（）或notifyAll（）方法唤醒其它一个或所有线程 而使用wait（）方法来使该线程处于阻塞状态 等待其它的线程用notify（）唤醒
一个实际的例子就是生产和销售 生产单元将产品生产出来放在仓库中 销售单元则从仓库中提走产品 在这个过程中 销售单元必须在仓库中有产品时才能提货 如果仓库中没有产品 则销售单元必须等待
程序中 假如我们定义一个仓库类store 该类的实例对象就相当于仓库 在store类中定义两个成员方法 store_in（） 用来模拟产品制造者往仓库中添加产品 strore_out（）方法则用来模拟销售者从仓库中取走产品 然后定义两个线程类 customer类 其中的run（）方法通过调用仓库类中的store_out（）从仓库中取走产品 模拟销售者 另外一个线程类procer中的run（）方法通过调用仓库类中的store_in（）方法向仓库添加产品 模拟产品制造者 在主类中创建并启动线程 实现向仓库中添加产品或取走产品
如果仓库类中的store_in（） 和store_out（）方法不声明同步 这就是个一般的多线程 我们知道 一个程序中的多线程是交替执行的 运行也是无序的 这样 就可能存在这样的问题
仓库中没有产品了 销售者还在不断光顾 而且还不停的在 取 产品 这在现实中是不可思义的 在程序中就表现为负值 如果将仓库类中的stroe_in（）和store_out（）方法声明同步 如上例所示 就控制了同一时刻只能有一个线程访问仓库对象中的同步方法 即一个生产类线程访问被声明为同步的store_in（）方法时 其它线程将不能够访问对象中的store_out（）同步方法 当然也不能访问store_in（）方法 必须等到该线程调用wait（）方法放弃钥匙 其它线程才有机会访问同步方法
lishixin/Article/program/Java/gj/201311/27301
Ⅳ java多线程操作数据库
首先，你的确定数据的主键是否可以返配使用序列自增。
如果可以那么你可以在插入数察纯据的时候获取序列里的值，这样数据就不会重复了。
其次，可以创建一个公共方漏没指法，进行数据的插入操作，并且方法类型声明为 static synchronized
类型，这样基本上就不会出现数据重复的现象了
最后，要看你是怎么获得待插入源数据了，这个获得数据源的方法也做成static synchronized的公
共方法。
Ⅵ 如何证明Java多线程中的成员变量数据是互不可见的
Java多线程里面有一个数据不可见的问题而我们知道使用volatile可以解决，但是如何证明这个多线程修改共享数据是不可见的呢？
很简单，看下面的一段代码：碰搜
private static boolean keepRunning=true;
public static void main(String[] args) throws Exception {
new Thread(
()->{
while (keepRunning){
//System.out.println();
}
}
).start();
Thread.sleep(1000);
keepRunning=false;
}
上面的代码是笑逗历在JDK8的环境下运行的，我们看到有一个静态的boolean变量的值是true，然后在main方法中我们声明又创建指携了一个新的线程，并使用lambda语法创建了一个循环，接着在线程启动后我们在主线程的最后一行里把boolean变量的值给改变了。
如果两个线程的数据是可见的，那么上面的程序是会自动终止的，如果不可见则会进入一个无限循环中。
我分别在windows系统和mac系统运行上面的程序，结果都是死循环，程序永远不会停止，这也证明了我们上面的结论，然后如果把 keepRunning 变量加上volatile修饰后，程序是可以终止的，这也正是volatile关键字的作用，可以使得多个线程之间的共享数据在修改后，对其他的线程立即可见。
Ⅶ Java如何处理多线程的数据同步问题
通过synchronize加锁进行喊宏实谨渗差现进行之间的互斥、通过wait、notify方法实现线程之间的同步。祥皮
Ⅷ java语言支持多线程它能同步共享数据处理不同的事件对吗
对。根据博客官网相关缓搜查询得知，java语言支持多线程是能同步共享数据处理不同的事件的。Java，是型喊一门面向对象编程语言，1990年代初由詹姆斯·高斯林等人开发出Java语言扰租历的雏形。
Ⅸ java多线程下如何保证数据的一致性
以mysql来说，可能出现脏读、不可重复读以及幻读，mysql默认设置是可重复读，即一次事务中不会读取到不同的数据。
可以做如下操作：
1）打开两个客户端，均设置为RR；
2）在一个事务中，查询某个操作查到某份数据；比如是某个字段version=1存在数据；
3）在另一个事务中，删除这份version=1的数据；删除后，在2所属的事务中查询数据是没有变化的，还是存在version=1的数据；
4）当我们在2所属的事务中继续更新数据，那么会发现更新不了，明明我们就看到了这份version=1的数据；
缓存一致性:
缓存一致，与什么一致？是与数据库一致，对外查询每个时刻一致；所以在针对于缓存与数据库之间该先更新哪一个呢？可能有人觉得我先更新数据库，再更新缓存不就行了吗？但是有想过个问题吗？
当用户已经支付成功了，更新到数据库，但是呢？你还在缓存中显示升宴森未支付，在用户点击频率很高并且数据库压力过大，来不及同步到缓存时，那你是不是很尴尬吵亩，这就是典型的不一致了。此时用户再支付，那你又告诉他已经支付了，那他会把你骂死的
那该怎么来做呢？我们可以这样，先更新缓存再更新数据库，那么存在什么问题呢？
1）缓存更新成功，但是数据库更新失败，而被其祥和它的并发线程访问到
2）缓存淘汰成功，但是数据库更新失败，这也会引发后期数据不一致