一到面试题，用10个线程向数据库中输入10000条记录

Question

public class MianShiTi implements Runnable{ /**
 * 自增ID
 */
private static int incrementId = 1;

public synchronized static int getincrementId(){
return incrementId++;
}

@Override
public void run() {

int id = 0;
while((id=getincrementId())<=1000){
System.out.println("插入数据主键:"+id+" 当前线程"+Thread.currentThread().getName()+" ");
}


} public static void main(String[] args) {

for (int i = 1; i <=10; i++) {
Thread thread = new Thread(new MianShiTi());
thread.setName("线程"+i);
thread.start();
}
}

}这样可否

Answer 1

步骤：
第一步： 写一个线程类，在里面写个循环，向表里插入1000次，
第二步：用for循环10次来new出写好的线程类。
这样就可以了。

Answer 2

一楼方式就可以，不过不必使用synchronized，只需要使用Atomicinteger 替换int 作为id就可以了。

Answer 3

public class Test6 extends Thread { static Connection conn = null;

static AtomicInteger id = new AtomicInteger(0);

static String sql = "insert into t_test(id, name) values(?, ?)";

static {

try {

conn = DriverManager.getConnection("jdbc:mysql://localhost/db_test, "testuser", "usertest");

} catch (SQLException e) {
e.printStackTrace();
}

} @Override
public void run() {

try {

PreparedStatement stmt = conn.prepareStatement(sql);

long millis = System.currentTimeMillis();

for (int i = 1; i <= 1000; i++) {

int a = id.incrementAndGet();

stmt.setInt(1, a);

stmt.setString(2, String.format("%05d", a));

stmt.addBatch();

if(i % 50 == 0) {
stmt.executeBatch();
}

}

stmt.executeBatch();

System.out.format("%s finished in %d ms\n", Thread.currentThread().getName(), System.currentTimeMillis() - millis);

} catch (SQLException e) {
e.printStackTrace();
}

} public static void main(String[] args) {


for(int i = 0; i < 10; i++) {

new Test6().start();

}

}}

Answer 4

ID一般都用十进制整数表示，题目要求又是十个线程，正好是0~9表示十个数。
所以，ID生成算法可以用个位数表示线程的0~9，除了个位数以外的其他位数，线程内自增就可以了。
示例代码：public class Test { static class InsertTask extends Thread{
private int taskId;//between 0(include) and 10(exclude)
private final int MaxRecords = 1000;
public void run(){
int recordId = 0;
for(int index =0;index<MaxRecords;index++){
recordId = index*10 + taskId;
doIndsert(recordId);
}
}
private void doIndsert(int recordId) {
// insert recordId,recordName,recordDate
}
}
/**
 * 测试用例
 */
public static void main(String[] args) {
final int GroupSize = 10;//必须10个线程，否则ID就乱了。
InsertTask[] taskGroup = new InsertTask[GroupSize];
for(int i=0;i<GroupSize;i++){
taskGroup[i] = new InsertTask();
taskGroup[i].taskId = i;
taskGroup[i].start();
}
}
}

Answer 5

我也写个，lz凑合看看：
public class SynchronizedClass {
/**
 * 插入次数
 */
public static int INSERT_TIME=10000;
/**
 * id号 从1开始
 */
public static int index=1;
/** 
 *  获取id  synchronized保证不会重复
 * @return
 */
public static synchronized int getIndex(){  
return index++;

}
/**判断插入次数是否足够了
 * @return
 */
public static synchronized boolean  isFinish(){
return index==INSERT_TIME?true:false;
}
}
public class Task implements Runnable{ @Override
public void run() {
// TODO Auto-generated method stub
while(true){
if(SynchronizedClass.isFinish()){
break;
}
TextBean textBean=new TextBean();
int index=SynchronizedClass.getIndex();
textBean.setDate("data"+index);
textBean.setName("name"+index);
textBean.setId(index);
textBean.insert();

}
}

 
public static void main(String args[]){

for(int i=0;i<10;i++){
new Thread(new Task()).start();

}

}public class TextBean {
private int id;
private String name =null;
private String date=null;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public boolean insert(){
/*
 * 插入数据库
 * */
return true;
}
}
 }

Answer 6

如果能够确保这张表内不存在数据，那么线程内自增即可
否则要先将表内ID数据给取出，自增过程中跳过该ID(主键禁止重复)

Answer 7

u can use AtomicInteger class generate id

Answer 8

10个线程，每个线程负责插入1000条数据，id也分成10组，就这样，no problem

Answer 9

package Mianshi;
import java.io.*;
import java.sql.*;
import tools.Mysql;
public class TenThread  {
private  int  count=0;
private  Connection conn=null;
private  String  name,data;
private  Mianshi[] mianshi = new Mianshi[10];
TenThread(){
   conn=Mysql.getConnection();
     for(int i=0;i<10;i++){
              mianshi[i]=new Mianshi();
       new Thread(mianshi[i]).start();
 }
}
 class  Mianshi   implements   Runnable{
private  String name=null;
        Mianshi(){
  // this.name=name;
}
 public void run(){
 while(count<1000){
    try {
     PreparedStatement ps = conn.prepareStatement("insert into mianshi values(?,?,?)");

    ps.setInt(1, count);
    ps.setString(2," name");
    ps.setString(3,"data");
   ps.execute();
    count++;
    System.out.println(Thread.currentThread().getName()+"载入第数据了"+count);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
   
 }
 
 }
   
  }
   public  static void main(String args[]){
   new TenThread();
   }
   
   }

Answer 10

用java的UUID类生成的id, 不是线程安全而且唯一的么?  搞这么复杂作甚?

Answer 11

楼上全是用Thread的，为什么不用concurrent api呢，简单方便，来一个吧
package demo;import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;public class Demo {
    // 保存id的列表
    private static List<Long> lst = new ArrayList<Long>();
    
    private void doInsert(int n){
        Callable<Long> handler = new Callable<Long>() {
            @Override
            public Long call() {
                long id = System.nanoTime(); 
                System.out.printf("%s 产生了 %d %n", 
                        Thread.currentThread().getName(),
                        id);                
                return id;
            }
        };
        
        // 产生10个线程的线程池
        ExecutorService es = Executors.newFixedThreadPool(n);
        Future<Long> future = null;
        for(int i=0;i<n;i++){
            future = es.submit(handler);
            try {
                lst.add(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        es.shutdown();
    }
    
    public static void main(String[] args) {
        Demo d = new Demo();
        d.doInsert(10);
        System.out.printf("id = %s", Demo.lst);
    }
}