在标准并行算法中只使用一个线程的原因可能是由于以下问题：

1. 并行算法的并发性不足，没有充分利用多线程的潜力。
2. 并行算法的实现中没有正确地使用并行化的技术和工具。

为了解决这个问题，可以采取以下方法来优化并行算法的实现，充分利用多线程的优势：

1. 使用多线程框架：使用支持并行计算的多线程框架，如Java中的Executor框架、OpenMP等。这些框架提供了方便的接口和工具，可以简化并行算法的实现。

2. 并行化关键部分：通过识别并行算法中的关键部分，将其并行化处理。可以使用多线程来同时处理多个任务，提高并行算法的运行效率。

3. 数据分割和分配：将需要处理的数据分割成多个子任务，并将这些子任务分配给不同的线程进行处理。可以使用分治算法、任务队列等技术来实现数据的分割和分配。

下面是一个使用Java的Executor框架来实现并行算法的示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ParallelAlgorithmExample {

    public static void main(String[] args) throws InterruptedException {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int sum = parallelSum(data);
        System.out.println("Sum: " + sum);
    }

    public static int parallelSum(int[] data) throws InterruptedException {
        int numThreads = Runtime.getRuntime().availableProcessors();
        ExecutorService executor = Executors.newFixedThreadPool(numThreads);

        int chunkSize = data.length / numThreads;
        int sum = 0;

        for (int i = 0; i < numThreads; i++) {
            int startIndex = i * chunkSize;
            int endIndex = (i == numThreads - 1) ? data.length : (i + 1) * chunkSize;
            int[] chunk = new int[endIndex - startIndex];
            System.arraycopy(data, startIndex, chunk, 0, endIndex - startIndex);

            // 使用多线程计算每个子任务的和
            executor.submit(() -> {
                int localSum = 0;
                for (int num : chunk) {
                    localSum += num;
                }
                synchronized (ParallelAlgorithmExample.class) {
                    sum += localSum;
                }
            });
        }

        executor.shutdown();
        executor.awaitTermination(10, TimeUnit.SECONDS);

        return sum;
    }
}

在上面的示例代码中，我们通过创建一个线程池并使用Executor框架来实现并行算法。首先，我们根据可用的处理器核心数创建一个线程池。然后，我们将数据分割成多个子任务，并将每个子任务提交给线程池中的一个线程进行处理。每个线程计算自己负责的子任务的和，并将结果累加到共享变量sum中。最后，我们等待所有线程完成任务，并返回总和sum。

这样，我们就成功地将标准并行算法改进为使用多个线程进行并行计算，充分利用了多线程的优势，提高了算法的执行效率。