There is no known easy way to "work on this" since it probably beyond reach of current techniques, and requires a major breakthrough in our understanding of number theory. Even the bounded gap conjecture was finally proved quite recently 2013 due to such breakthrough by Zhang (proving a bounded gap between consecutive primes).

See:

General Info:  https://en.wikipedia.org/wiki/Twin_prime   http://michaelnielsen.org/polymath1/index.php?title=Bounded_gaps_between_primes

The social/ story-like background: http://www.slate.com/articles/health_and_science/do_the_math/2013/05/yitang_zhang_twin_primes_conjecture_a_huge_discovery_about_prime_numbers.html

Some more number theory on the subject:  https://terrytao.wordpress.com/tag/twin-prime-conjecture/

Not being a theoretical mathematician, I certainly don't have anything insightful to add to Moti's reply (which was a revelation to me, by the way). Just a personal story on the subject of twin primes.

Years ago, I saw what I think was a Barbara Streisand movie (I know, seems unlikely right?), in which a professor described twin primes, in the movie script. Fascinating, so while sitting there in the theater, the idea intrigued me to demonstrate these. So the next day, I wrote the simple program, attached, to see what this phenomenon looks like. It's written in QuickBasic, so it should be easy enough to follow. I hesitate to attach an executable, because people worry about viruses.

Anyway, sure enough, let the program run as long as you want, those twin primes keep showing up! Frequently! Who knew? The percentage of numbers that turn out to be prime, and the gap between prime numbers, are also demonstrated. You can hit the key to freeze the program anywhere you like. Then hit to resume.

For instance,

The 351,730th prime number is 5,050,187

The 351,731st prime number is  5,050,189

So this is a twin prime. And perhaps surprisingly, 6.965 percent of numbers, up to that point, are prime. The percentage drops very slowly, by the time you're up to these numbers. And the way the output is formatted, you can see how often twin pairs flash by. Incredibly often.

Thanks you albert, i already test using C# and it always run, until i break it.... and i have same point to waldemar.... it's always problem that await us to solve it... still waiting another answer.... and thank you for moti young,  i had read that link before but still a problem for me.... who really knows

True enough, Robbi, all such demos eventually break. I dimensioned every variable as _FLOAT (using QB64). Not because I needed floating point, but because _FLOAT uses 10-byte variables, the most available for this language:

http://www.qb64.net/wiki/index.php/FLOAT

"a QB64 _FLOAT is a 10-byte floating point number"

As long as I've let this run, twin primes keep flashing by on the display. Eventually, you run out of bits. Of course, I also agree with Waldemar. Who really knows what happens ultimately? That's the stuff of theoretical math, and less of what might keep an engineer awake at night!!

most of programming language will have a same result if we try, but... if this twin number could be solved... its kind amazing especially in cryptography algorithm like RSA example, of we could use this for mutated key generate (maybe), break it RSA Encryption, and many more... like albert say "might keep an engineer awake at night"

Unfortunately, you can't solve this by programming, even aside from the issues of how large an integer you can represent in your language.  You can easily write a program to loop over positive integers, test them for primeness, and report whenever it finds a twin prime.  Obviously, the program will never finish, because there's always another integer to try.  If you see that it hasn't output a new twin-prime pair in "a long time", you can speculate that you've found the last one, but it's always possible that you've just found an unusually large gap between twin primes, and the next one is just around the corner.

There are other problems that "can't be solved by programming", of which the best-known is the Halting Problem, "will program P ever finish, given input x?".  The Halting Problem can be rephrased as "is there a number of steps in which program P will finish, given input x?"  There's a class of problems called \Sigma_1, which can be formulated as "is there a positive integer N such that ?" (where "blah" is something you know how to decide yes-or-no).  For any such problem, you can "semi-solve" it with a program which is guaranteed to say "yes" if the right answer is "yes", but will run forever if the right answer is "no".  In this case,

for N = 1 to infinity

  if P(x) finishes in N steps, break out of the loop

if you ever broke out of the loop, P(x) halts; if you didn't, it doesn't.

Similarly, a \Pi_1 problem is one of the form "do all positive integers M have property ?".  For a \Pi_1 problem, you can easily write a program which is guaranteed to say "no" if the right answer is "no", but will run forever if the right answer is "yes".

The twin primes problem is worse: it's neither \Sigma_1 nor \Pi_1, but \Pi_2: "is it true that for all positive integers M, there is another positive integer N, such that ?"  Speciifically, is it true that for all positive integers M, is there an N > M such that N and N+2 are both prime?  To solve this with a program, you could use two nested infinite loops:

for N = 1 to infinity

  for M = N+1 to infiinity

    if M and M+2 are both prime, break out of the inner loop

  if you never broke out of the inner loop, break out of the outer loop

if you ever broke out of the outer loop, there are finitely many twin prime pairs; if you didn't, there are infinitely many.

Of course, we're mathematicians, so we can make things even more impossible.  A \Pi_3  problem is of the form "is it true that for all positive integers M, there is another positive integer N such that for all positive integers Q, ?"  Such problems can be solved with three nested infinite loops, each one breaking only if the one inside it didn't.  And so on, to infinitely many degrees of greater and greater impossibility.

Which doesn't mean the twin-primes conjecture can't be solved; it just won't be solved (either "yes" OR "no") by exhaustive computation of the above forms.

>> any suggestion how to solve these problem? 

You have to find a new way of looking at primes. For example find some new mathematical relationship in primes, or find some new rule of order in primes.

This isn't easy, because some of the most brilliant mathematicians to ever walk the earth have been messing around with prime numbers for literally centuries, even millennia, and that means the vast majority of "low hanging" fruit has been picked. Perhaps all of it, because many obsessive compulsive geniuses of the past devoted enormous efforts to prime problems, without cracking them.

That doesn't mean somebody can't have a new idea, but it does make it unlikely. If the problem is cracked, it will likely be by "seeing further by standing on the shoulders of giants", meaning by somebody that spends a few decades of their life learning what has been done already, in order to find some little over-looked crack in the wall they can widen into a path that leads to a new insight and solution.