The following is directly taken from pages 358-360 of The Nature of Computation by <PERSON> and <PERSON> and I think addresses your problem directly.
Imagine that you run a computer center with $p$ identical machines, or a parallel computer with $p$ processors, for some constant $p$. You are given $n$ jobs with running times $t_1,t_2,...,t_n$. Your task is to find a schedule - a function $f:{1,...,n}\rightarrow{1,...,p}$ that assigns the $j$th job to the $f(j)$th machine.
The load on the $j$th machine is the total time it takes to run the jobs assigned to it, $$ L_j = \sum_{i:f(i)=j} t_i\,. $$ Since the machines run in parallel, the time it takes us to finish all the jobs is the maximum load on any machine, $$ M=\max_{i\leq j\leq p} L_j\,. $$ We call this time the makespan, and your goal is to minimize it. This gives the following problem:
Makespan
Input: A set of $n$ running times $t_i\geq0,\,i=1,...,n$
Output: A function $f: {1,...,n}\rightarrow{1,...,p}$ that minimizes the makespan $$M = \max_{1 \leq j \leq p} \sum_{i:f(i)=j}t_i$$
Exercise 9.3 Reduce Integer Partitioning to the case of Makespan where $p=2$.
There is, however, a simple algorithm that comes with a quality guarantee. The idea is to divide tasks into two groups, "large" and "small", and schedule the large tasks first. Let $T_{\text{tot}}=\sum_{j=1}^n t_j$ be the total running time of all the tasks. We choose some constant $\eta > 0$, say $\eta = 1/10$. We call the $j$th task large if its running time is at least a fraction $\eta$ of the total, $t_j \geq \eta\,T_{\text{tot}}$, and small if $t_j < \eta\,T_{\text{tot}}$.
The algorithm then proceeds in two phases:
1. Find a schedule that minimizes the makespan of the large tasks, using exhaustive search.
2. 143
Distribute the small tasks by giving each one to the machine with the smallest load so far, regardless of that tasks's running time.
How long does this algorithm take? Since there are at most $1/\eta$ large tasks, there are $p^{1/\eta}$ ways to schedule them. Since $p$ and $\eta$ are constants, this gives a constant number of possible schedules to explore in phase 1, and we can check all of them in polynomial time using exhaustive search. Phase 2 clearly runs in polynomial time as well.
Now let $M$ denote the makespan of the schedule produced by this algorithm. How does it compare to $M_{\text{opt}}$? Let $M_{\text{large}}$ denote the maximum load of a machine after phase 1, i.e., the minimum makespan of the large tasks. Since adding the small tasks can only increase the makespan, we have $M_{\text{large}} \leq M_{\text{opt}}$. If the algorithm manages to fit all the small tasks in phase 2 without increasing the makespan, putting them on machines with load less than $M_{\text{large}}$, then $M = M_{\text{large}}$. But since $M_{\text{opt}} \leq M$, in this case $M = M_{\text{opt}}$ and the algorithm performs perfectly.
So, we will focus on the harder case where the makespan increases in phase 2, so that $M > M_{\text{large}}$ and our schedule for the small tasks might not be optimal. Let $L_j$ denote the load of machine $j$ after phase 2. Without loss of generality, we can assume that $L_1 \geq L_2 \geq ... \geq L_p$. Since $L_1 = M > M_{\text{large}}$, we know that at least one small task was added to machine 1.
Let $t$ be the running time of the last such task. 143