Java让线程返回一些东西到主线程

我被什么事缠住了，似乎想不出解决办法。我有一个名为dbSelect的函数，它会创建一个线程来运行MySQL查询并获取一个

ResultSet

，但是我需要我的

dbSelect

来获取并返回该

ResultSet

。以下是我所拥有的：

public class Utils {
    public static void dbSelect(String query){
        selectQuery = query;
        Thread selectThread = new selectThreadClass();
        selectThread.start();
    }
}
class selectThreadClass extends Thread {
    public void run(){
        perform();
    }

    public ResultSet perform(){
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/lob/?user=root&password=");

            Statement s = conn.createStatement();
            ResultSet rs = s.executeQuery(Utils.selectQuery);
            return rs;
        }catch (SQLException | InstantiationException | IllegalAccessException | ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }
    }
}

有谁能帮我获取它，以便

dbSelect

从线程返回

ResultSet

？谢谢

使用

公共接口可调用{
V call（）抛出异常；
}

run

不会返回结果。
使用al或使用共享变量并在

Utils

中轮询/

等待

，直到

SelectThreadClass

的结果可用。

---

但是我建议使用

可调用的

，因为它完全适合任务

而不是可运行的使用可调用的

public class SelectCallableClass implements Callable<ResultSet> {

    public ResultSet call() throws Exception {
        return perform();
    }

    public ResultSet perform(){
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/lob/?user=root&password=");

            Statement s = conn.createStatement();
            ResultSet rs = s.executeQuery(Utils.selectQuery);
            return rs;
        }catch (SQLException | InstantiationException | IllegalAccessException | ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }
    }
}

上面的代码执行以下操作（从doc）。提交一个返回值的任务以供执行，并返回一个表示任务挂起结果的Future>。未来的获取方法 将在成功完成后返回任务的结果

从我这边来试试

我修改了代码，得到了使用List保存ResultSet中的值的解决方案，但我只有一个问题 也就是说，我无法在Callable中以类型（ResultSet）的形式获取结果

不知怎的，当我尝试去做时，结果集是空的 使用future get（）函数检索值

ResultSet rs=（ResultSet）future.get（）

下面是一段不起作用的代码

ExecutorService service=Executors.newFixedThreadPool(1);
Callable<ResultSet> callable = new SelectThreadResultSet();
Future<ResultSet> future = service.submit(callable);
ResultSet rs = (ResultSet)future.get();
// Here I dont get any values
while(rs.next()){
    System.out.println(rs.getString("EMPLOYEE"));
}

ExecutorService=Executors.newFixedThreadPool（1）；
Callable Callable=新建SelectThreadResultSet（）；
Future=service.submit（可调用）；
ResultSet rs=（ResultSet）future.get（）；
//这里我没有得到任何值
while（rs.next（））{
System.out.println（rs.getString（“雇员”）；
}

请在下面找到适合我的解决方案，我使用的列表 保存值并返回它

类别SelectThreadClass：

public class SelectThreadClass implements Callable<List<String>> {

    public List<String> call(){
        ResultSet rs = null;
        List<String> strList = new ArrayList<String>();
        try {
            rs  = perform();
            while(rs.next()){
                strList.add(rs.getString("EMPNAME"));
            }
            System.out.println("Passed");

        } catch (InstantiationException | IllegalAccessException | SQLException e) {
            e.printStackTrace();
        }
        return strList;
    }

    public ResultSet perform() throws InstantiationException, IllegalAccessException, SQLException{
        Connection conn = null;
        try {
            Class.forName("org.sqlite.JDBC");
            try {
                conn = DriverManager.getConnection("jdbc:sqlite:C:\\SqlLite\\EMPLOYEE.db");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            Statement s = null;
            try {
                s = conn.createStatement();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            ResultSet rs = null;
            try {
                rs = s.executeQuery(Utils.selectQuery);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return rs;
        }catch (ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }
    }
}

public类SelectThreadClass实现可调用{
公共列表调用（）{
结果集rs=null；
List strList=new ArrayList（）；
试一试{
rs=执行（）；
while（rs.next（））{
添加（rs.getString（“EMPNAME”）；
}
系统输出打印项次（“通过”）；
}catch（实例化异常| IllegalacessException | SQLException）{
e、 printStackTrace（）；
}
返回strList；
}
public ResultSet perform（）抛出实例化异常、IllegaccessException、SQLException{
连接conn=null；
试一试{
Class.forName（“org.sqlite.JDBC”）；
试一试{
conn=DriverManager.getConnection（“jdbc:sqlite:C:\\SqlLite\\EMPLOYEE.db”）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
语句s=null；
试一试{
s=conn.createStatement（）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
结果集rs=null；
试一试{
rs=s.executeQuery（Utils.selectQuery）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回rs；
}catch（classnotfounde异常）{
e、 printStackTrace（）；
返回null；
}
}
}

类别UTIL：

public class Utils {

    public static String selectQuery = "SELECT EMPNAME FROM EMPLOYEEDETAILS";
    public static void dbSelect(String query) throws InterruptedException, ExecutionException, SQLException{
        ExecutorService service=Executors.newFixedThreadPool(1);
        Callable<List<String>> callable = new SelectThreadClass();

        Future<List<String>> future = service.submit(callable);

        List<String> empList = future.get();
        for(String emp : empList){
            System.out.println(emp);
        }
    }

    public static void main(String args[]) throws InterruptedException, ExecutionException, SQLException{
        dbSelect("SELECT EMPNAME FROM EMPLOYEEDETAILS");
    }

}

公共类Utils{
公共静态字符串selectQuery=“从EMPLOYEEDETAILS中选择EMPNAME”；
公共静态void dbSelect（字符串查询）引发InterruptedException、ExecutionException、SQLException{
ExecutorService=Executors.newFixedThreadPool（1）；
Callable Callable=新建SelectThreadClass（）；
Future=service.submit（可调用）；
List empList=future.get（）；
for（字符串emp:empList）{
系统输出打印项次（emp）；
}
}
公共静态void main（字符串args[]）引发InterruptedException、ExecutionException、SQLException{
dbSelect（“从EMPLOYEEDETAILS中选择EMPNAME”）；
}
}

您只需在Thread类中拥有一个属性，然后获得该属性

public class Utils {
    public static void dbSelect(String query){
        selectQuery = query;
        Thread selectThread = new selectThreadClass();
        selectThread.start();

        ((SelectThreadClass) selectThread).getResult();
    }
}

class selectThreadClass extends Thread {
    ResultSet rs = null;

    public ResultSet getResult(){
        return rs;
    }

    public void run(){
        rs = perform();
    }

    public ResultSet perform(){
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/lob/?user=root&password=");

            Statement s = conn.createStatement();
            return s.executeQuery(Utils.selectQuery);
        } catch (SQLException | InstantiationException | IllegalAccessException | ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }
    }
}

---

唯一的问题是，您可能最终会从dbutil中处理连接关闭和其他内容，或者，您可以将结果集转换为任何java类，然后返回java对象列表而不是结果集

不要扩展

线程

，使用

可运行

，扩展可观察的

并观察它。有很多种方法，但那是一种突然出现在我脑海中的方法。与执行器一起使用Callables是另一种方法。与执行器一起使用。您可以在中阅读更多关于此的信息。好的，那么这是否需要成为它自己的文件？另外，既然

future

正在调用它，我将如何获取我的ResultSet？future.get（）将返回可调用的返回值，阻塞调用线程，直到可调用的执行完毕，返回值准备就绪。好的，我将尽快测试，如果可行，接受答案：）啊，这是很多，但我会尝试。谢谢：）好的，解决方案很简单，最好的部分是，它可以工作：）对不起，我有点忙-我很快会测试它，并接受它是否工作：）什么数据将进入

员工列表

，因为当我试着打印它的项目时，它会给我一个

NPI

。

public class Utils {

    public static String selectQuery = "SELECT EMPNAME FROM EMPLOYEEDETAILS";
    public static void dbSelect(String query) throws InterruptedException, ExecutionException, SQLException{
        ExecutorService service=Executors.newFixedThreadPool(1);
        Callable<List<String>> callable = new SelectThreadClass();

        Future<List<String>> future = service.submit(callable);

        List<String> empList = future.get();
        for(String emp : empList){
            System.out.println(emp);
        }
    }

    public static void main(String args[]) throws InterruptedException, ExecutionException, SQLException{
        dbSelect("SELECT EMPNAME FROM EMPLOYEEDETAILS");
    }

}

public class Utils {
    public static void dbSelect(String query){
        selectQuery = query;
        Thread selectThread = new selectThreadClass();
        selectThread.start();

        ((SelectThreadClass) selectThread).getResult();
    }
}

class selectThreadClass extends Thread {
    ResultSet rs = null;

    public ResultSet getResult(){
        return rs;
    }

    public void run(){
        rs = perform();
    }

    public ResultSet perform(){
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            conn = DriverManager.getConnection("jdbc:mysql://localhost/lob/?user=root&password=");

            Statement s = conn.createStatement();
            return s.executeQuery(Utils.selectQuery);
        } catch (SQLException | InstantiationException | IllegalAccessException | ClassNotFoundException e){
            e.printStackTrace();
            return null;
        }
    }
}