It will depend on what you're trying to achieve. For example, if you need to reach DC 25, and $x = 4$ and $y = 5$, the advantage on the roll with $x$ doesn't matter; you'll never roll higher than 24. With the +5, you'll at least have a 5% chance.

Here (scroll down to "Advantage versus Simple Bonuses") is a table which shows which bonus (difference between x and y) corresponds to having advantage or not.

(source: Zero Hit Points)

If you only care about maximising the expected result, as opposed to your odds of hitting a specific target number (for instance, you might be making a contested roll against someone else, like in a grapple, or otherwise don't know the target number ahead of time) this is a pretty simple comparison. Having advantage on a d20 roll increases the expected result from an average of 10.5 to 13.82 (illustrated by this anydice program); that's a benefit of +3.32.

Therefore, in order for a roll without advantage to have a higher expected result than a roll with advantage, the modifier on the normal roll needs to be four or more points better than the modifier on the advantaged roll. +3 with advantage is worse than +7 normally, and so on.

First, subtract $x$ both from $y$ and from the target number you're rolling against. Then look at this graph:

In the graph, find the position on the horizontal axis that matches the target number (minus $x$) that you're trying to meet or exceed, and the colored line that matches the extra bonus $y-x$ to the roll without advantage. If that colored line is higher that the curved black line at that position on the horizontal axis, you should choose the higher bonus over advantage.

(Specifically, the various lines in the graph show the probability of meeting or exceeding a given target number with various rolls: the black curved line is for d20 with advantage but no bonus, while the five different colored straight lines on top of it are for d20+1 to d20+5.)

Or, to summarize, you should choose a plain $+y$ bonus over advantage $+x$ when...

• 
  $y = x + 1$ and the target number is at most $x+2$ or at least $x+20$;


• 
  $y = x + 2$ and the target number is at most $x+3$ or at least $x+19$;


• 
  $y = x + 3$ and the target number is at most $x+4$ or at least $x+18$;


• 
  $y = x + 4$ and the target number is at most $x+6$ or at least $x+16$; or


• 
  $y ge x + 5$.

(As noted by Xirema, things can change a little if you're e.g. making an attack roll and care about crits. Rolling with advantage has a 9.75% chance of giving you a natural 20, and only a 0.25% chance of a natural 1, whereas with a normal d20 roll both 1s and 20s show up 5% of the time each. Whether those differences in crit odds are worth trading for a somewhat worse chance to hit depends both on the target DC and on how much you value crits.)

tl;dr- Assuming neither roll is a sure thing, then advantage has better odds if$$
frac
left(textDC - textadvantage bonus - 1right)^2textDC - textnormal bonus - 1 phantom^2 < 20
tag1
,.$$Here's an online C# script to play with this. Details at the bottom of this answer.

Example

1. You have to beat a $textDC = 10 .$



2. 
   

   You have two options:

   
   
   

   • Roll normally with a bonus of $+5 .$

   
   

   • Roll with advantage and a bonus of $+1 .$

   
   



3. Plug this into $operatornameEq.left(1right)$ to find:$$
   fracleft(textDC - textadvantage bonus - 1right)^2textDC - textnormal bonus - 1 phantom^2
   ~=~
   fracleft(10 - 1 - 1right)^210 - 5 - 1
   ~=~
   frac8^24
   ~=~16
   ~<~ 20
   ,.$$




4. Since $16 < 20 ,$ this inequality is $textttTRUE ,$ and therefore rolling with advantage is better.



5. 
   

   By contrast, if the $textDC$ were $17$ instead of $10 ,$ then the inequality would've reduced to$$
   fracleft(textDC - textadvantage bonus - 1right)^2textDC - textnormal bonus - 1 phantom^2
   ~=~
   fracleft(17 - 1 - 1right)^217 - 5 - 1
   ~=~
   frac15^211
   ~=~ sim 20.45
   ~<~ 20
   ,,$$

   
   
   

   and since $sim 20.45 < 20$ is $textttFALSE ,$ this means that the odds aren't better when rolling with advantage. So, in this case, it'd seem better to roll normally with $+5$ rather than with $+1$ and advantage.

   
   

Explanation

First:

1. If either option is a sure-thing, just do it.




2. If neither option has a chance, nothing you can do anyway.

So this leaves only the case in which both options have some non-certain possibility.

Then, the odds of failing to beat a DC on a single roll are
$$
P_textroll
~=~ 5 , left(left[textDCright] - left[textbonusright] - 1right) , %
,,
$$and the odds of failing to beat a DC with advantage are$$
P_beginarrayctextroll with \[-10px] textadvantageendarray
~=~ P_textroll^2
~=~ left(5 , left(left[textDCright] - left[textbonusright] - 1right) , %right)^2
~=~ 0.25 , left(left[textDCright] - left[textbonusright] - 1right)^2 , %
,.$$

So, your odds of failure with advantage are lower when
$$
0.25 , left(left[textDCright] - left[textbonusright]_textadvantage - 1right)^2 , %
~<~
5 , left(left[textDCright] - left[textbonusright]_textnormal - 1right) , %
,,$$
or
$$
frac
left(left[textDCright] - left[textbonusright]_textadvantage - 1right)^2

left[textDCright] - left[textbonusright]_textnormal - 1

~<~
20
,.
$$

To make that a little more intuitive, let's write it as
$$
frac
left(textDC - textadvantage bonus - 1right)^2

textDC - textnormal bonus - 1

~<~
20
,.
$$

Notes

1. The tl;dr advice recommends against rolling with advantage when the odds are the same either way. I chose this convention since it's less work. But, if someone likes to roll, then they might instead roll with advantage if
   $$
   frac
   left(textDC - textadvantage bonus - 1right)^2textDC - textnormal bonus - 1 phantom^2 le 20
   ,.$$




2. The above logic assumes that the d20-die is fair. If it's not, then I'd guess that rolling without advantage is a bit better than it would normally be because an unfair die would seem to have less variability between rolls. Since most dice probably aren't perfectly fair, a hardcore optimizer might prefer to roll without advantage when$$
   frac
   left(textDC - textadvantage bonus - 1right)^2textDC - textnormal bonus - 1 phantom^2 approx 20
   ,.$$




3. The $`` 20 "$ in the inequality is no coincidence; it corresponds to the "20" in "d20". Likewise, the $`` 1 "$ corresponds to the minimum die value. So if another sort of die is used, this inequality can be generalized to$$
   frac
   left(textDC - textadvantage bonus - textmin die valueright)^2textDC - textnormal bonus - textmin die value phantom^2
   ~<~
   textmax die value - textmin die value + 1
   ,.$$




4. The above derivation focused on the probability of failure, rather than the probability of success, because the math would've been a bit uglier for rolling with advantage if we focused on maximizing success (rather than minimizing error). However, if anyone does this same calculation for rolling with disadvantage, the math should be cleaner if you instead derive it by focusing on maximizing success. The reason for this is that advantage/disadvantage requires a second die roll only on failure/success of the first roll.

C# script to play with this

I was going to attach a JavaScript snippet here, but I guess that feature's not on this StackExchange. So, here's a C# script that can be run online.

Notes:

1. 
   

   To use it, call Report(dc, bonus_normal, bonus_advantage);, and it'll tell you which is better.

   
   
   
   • 
     

     Currently, it's pre-loaded to call Report(10, 5, 1); and Report(17, 5, 1); to demonstrate the example given near the top of this answer. This should return:

     
     
     

     
     

     For DC = 10 Bonus (normal) = 5 Bonus (advantage) = 1:
     Your odds are better with the power of ADVANTAGE!
     
     For DC = 17 Bonus (normal) = 5 Bonus (advantage) = 1:
     Advantage is for losers; roll normally!
     

     
     

     
     
   
   



2. By default, it uses a d20, with a minimum value of 1 and a maximum value of 20. Both of these values can be changed in the code.




3. $operatornameEq.left(1right)$ (and its generalization, as used in this script) assume that, if the odds can't be improved by advantage, you prefer to roll normally (since it's less rolling).




4. $operatornameEq.left(1right)$ assumes success and failure are both possible with both advantage and normal rolling. This script checks to ensure that that's true before using $operatornameEq.left(1right) .$

Source code (C#):

using System;

public class Program

 // A typical d20 has a minimum value of 1 and a maximum of 20:
 public const long MINIMUM_DIE_VALUE = 1;
 public const long MAXIMUM_DIE_VALUE = 20;

 public static void RunExample()
 
 Report(
 10
 , 5
 , 1
 );

 Report(
 17
 , 5
 , 1
 );
 

 public static void Report(
 long dc
 , long bonus_normal
 , long bonus_advantage
 )
 
 var stringMessage = 
 "FortDC = "
 + dc.ToString()
 + "tBonus (normal) = "
 + bonus_normal.ToString()
 + "tBonus (advantage) = "
 + bonus_advantage.ToString()
 + ":"
 + System.Environment.NewLine
 ;

 if (ShouldRollWithAdvantage(
 dc
 , bonus_normal
 , bonus_advantage
 ))
 
 stringMessage += "Your odds are better with the power of ADVANTAGE!";
 //Console.WriteLine("Your odds are better with the power of ADVANTAGE!");
 
 else
 
 stringMessage += "Advantage is for losers; roll normally!";
 //Console.WriteLine("Advantage is for losers; roll normally!");
 

 Console.WriteLine(stringMessage);
 Console.WriteLine();
 

 public static bool ShouldRollWithAdvantage(
 long dc
 , long bonus_normal
 , long bonus_advantage
 )
 
 // Case 1:
 // If rolling with advantage can't succeed, then just roll normally.
 // Doesn't matter if rolling normally can't succeed, either, because if
 // you're going to fail either way, may as well only roll once.
 if (dc - bonus_advantage > MAXIMUM_DIE_VALUE)
 
 return false;
 

 // Case 2:
 // If rolling without advantage can't succeed, then roll with advantage.
 if (dc - bonus_normal > MAXIMUM_DIE_VALUE)
 
 return true;
 

 // Case 3:
 // If rolling without advantage always succeeds, then roll without advantage.
 if (dc - bonus_normal <= MINIMUM_DIE_VALUE)
 
 return false;
 

 // Case 4:
 // If rolling with advntage always succeeds, then roll with advantage.
 if (dc - bonus_advantage <= MINIMUM_DIE_VALUE)
 
 return true;
 

 // Case 5:
 // Since rolling with advantage and rolling without advantage are both
 // possible-but-not-guaranteed, we compare their odds of success.
 // 
 // This method checks if
 // (DC - bonus_advantage - 1)^2
 // is less than
 // 20 * (DC - bonus_normal - 1)
 // instead of the fraction to avoid floating-point values.
 
 var leftHandSide = (dc - bonus_advantage - MINIMUM_DIE_VALUE);
 leftHandSide *= leftHandSide;

 var rightHandSide = (MAXIMUM_DIE_VALUE - MINIMUM_DIE_VALUE + 1) * (dc - bonus_normal - MINIMUM_DIE_VALUE);

 var shouldRollWithAdvantage = leftHandSide < rightHandSide;

 return shouldRollWithAdvantage;
 
 

 private static bool TryValidateProgramConstants(
 out string errorMessage
 )
 
 if (!(MINIMUM_DIE_VALUE < MAXIMUM_DIE_VALUE))
 
 errorMessage = "Maximum die value must be greater than minimum die value.";
 return false;
 

 if (MINIMUM_DIE_VALUE < -1000)
 
 errorMessage = "Unreasonably low minimum die value.";
 return false;
 

 if (MAXIMUM_DIE_VALUE > 1000)
 
 errorMessage = "Unreasonably high maximum die value.";
 return false;
 

 errorMessage = default(string);
 return true;
 

 public static void Main()
 
 string errorMessage;
 if (TryValidateProgramConstants(out errorMessage))
 
 RunExample();
 
 else
 
 Console.WriteLine("Error in program validation; aborting run.");

 if (!string.IsNullOrWhiteSpace(errorMessage))
 
 Console.WriteLine(errorMessage);