如果要使用Socket实现Hive数据库到另一个Hive数据库的数据同步，可以按照以下步骤进行：

1. 准备工作

首先需要在本地安装好Hadoop和Hive，确保可以连接到源数据库和目标数据库。同时也需要了解Java Socket编程的基础知识。

1. 配置文件

创建一个配置文件，存储源数据库和目标数据库的连接信息、表名等信息。这个配置文件可以使用properties或者xml格式。

1. 读取源数据库数据

使用Hive JDBC驱动获取源数据库中的数据，并将其保存到Java对象中。这里可以使用ResultSet来读取查询结果。

1. 使用Socket传输数据

将读取到的数据通过Socket发送给接收端。在发送数据时，需要注意序列化和反序列化操作。

1. 接收端处理数据

接收端监听Socket连接，并接收从发送端发来的数据。接收到数据后，需要进行反序列化操作，并将其写入目标数据库中。

1. 定时任务实现自动同步

使用定时任务框架（比如Quartz）实现周期性地从源数据库同步数据到目标数据库。

代码示例：

1. 配置文件示例（database.properties）

# 源数据库配置
source.driverClassName=org.apache.hive.jdbc.HiveDriver
source.url=jdbc:hive2://localhost:10000/source_database
source.username=hive
source.password=hive123

# 目标数据库配置
target.driverClassName=org.apache.hive.jdbc.HiveDriver
target.url=jdbc:hive2://localhost:10000/target_database
target.username=hive
target.password=hive123

# 数据表名
table.name=user_info

# Socket连接配置
socket.host=localhost
socket.port=8888

1. Java代码示例

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
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;
import java.util.Properties;

public class SyncData {
    private Properties props;

    public SyncData(Properties props) {
        this.props = props;
    }

    public void sync() throws SQLException, IOException {
        // 获取源数据库连接
        Connection sourceConn = DriverManager.getConnection(props.getProperty("source.url"), props.getProperty("source.username"), props.getProperty("source.password"));

        // 查询源数据库数据并保存到Java对象中
        List<UserInfo> userList = new ArrayList<>();
        String sql = "select * from " + props.getProperty("table.name");
        PreparedStatement pstmt = sourceConn.prepareStatement(sql);
        ResultSet rs = pstmt.executeQuery();
        while (rs.next()) {
            UserInfo user = new UserInfo();
            user.setId(rs.getInt(1));
            user.setName(rs.getString(2));
            user.setEmail(rs.getString(3));
            userList.add(user);
        }
        
        // 使用Socket传输数据到接收端
        Socket socket = new Socket(props.getProperty("socket.host"), Integer.parseInt(props.getProperty("socket.port")));
        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
        oos.writeObject(userList);
        
        // 关闭资源
        oos.close();
        socket.close();
        rs.close();
        pstmt.close();
    }
}

1. 接收端处理数据

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

public class DataReceiver {
    private Properties props;

    public DataReceiver(Properties props) {
        this.props = props;
    }

    public void start() throws IOException, ClassNotFoundException, SQLException {
        // 监听Socket连接
        ServerSocket serverSocket = new ServerSocket(Integer.parseInt(props.getProperty("socket.port")));

        while (true) {
            // 接收数据并写入目标数据库中
            Socket socket = serverSocket.accept();
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            List<UserInfo> userList = (List<UserInfo>) ois.readObject();

            Connection conn = DriverManager.getConnection(props.getProperty("target.url"), props.getProperty("target.username"), props.getProperty("target.password"));

            for (UserInfo user : userList) {
                String sql = "insert into " + props.getProperty("table.name") + " values (?, ?, ?)";
                PreparedStatement pstmt = conn.prepareStatement(sql);
                pstmt.setInt(1, user.getId());
                pstmt.setString(2, user.getName());
                pstmt.setString(3, user.getEmail());
                pstmt.executeUpdate();
                pstmt.close();
            }
            
            // 关闭资源
            ois.close();
            socket.close();
            conn.close();
        }
    }
}

1. 定时任务示例（使用Quartz实现）

import java.io.IOException;
import java.util.Properties;

import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class SyncJob implements Job {
    private Properties props;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
         try {
             SyncData syncData = new SyncData(props);
             syncData.sync();
         } catch (SQLException | IOException e) {
             e.printStackTrace();
         }
    }

    public void setProps(Properties props) {
        this.props = props;
    }

    public static void main(String[] args) throws SchedulerException, IOException, ClassNotFoundException, SQLException {
        // 读取配置文件
        Properties props = new Properties();
        props.load(SyncJob.class.getResourceAsStream("database.properties"));

        // 创建任务
        JobDetail jobDetail = JobBuilder.newJob(SyncJob.class).withIdentity("syncJob", "group1").build();
        ((SyncJob)jobDetail.getJobDataMap().get("job")).setProps(props);

        // 创建触发器
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) // 每隔5秒执行一次
                .build();

        // 启动定时任务调度器
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();

        // 启动数据接收端
        DataReceiver receiver = new DataReceiver(props);
        receiver.start();
    }
}