#include <iostream>
#include <vector>
#include <chrono>

using namespace std;

uint64_t primeLimit = 1000000000;
uint64_t searchStart = 0; //999900000; 
uint64_t searchEnd = 100000; //primeLimit
uint64_t range = 6;

int main()
{	
	cout << "Double Twin Primes within range " << range << ":" << endl << endl;

	////////////////////////// Generate primes lookup table ///////////////////////////////////////////////////////////

	cout << "Primes lookup table is produced until " << primeLimit;
	vector<bool> primes(primeLimit + 1, true); // calculated primes
	primes.at(0) = primes.at(1) = false;
	uint64_t iMax = (uint64_t)sqrt((double)primeLimit) + 1; 
	for (uint64_t i = 2; i < iMax; ++i)
		if (primes.at(i))
			for (uint64_t j = 2 * i; j < primeLimit + 1; j += i)
				primes.at(j) = false; // Erastothenes sieve
	cout << " (finished)" << endl;

    //////////////////////////  Search Double Twin Primes ///////////////////////////////////////////////////////////////

	cout << "Twin Primes searched from " << searchStart << " to " << searchEnd << ":" << endl;

	auto start_time = chrono::high_resolution_clock::now();

	uint64_t p_old = 0;

	for (uint64_t p = searchStart; p <= searchEnd; ++p)
	{
		if (primes.at(p) && primes.at(p+2))
		{
			auto end_time = chrono::high_resolution_clock::now();
			uint64_t delta = p - p_old;
			if ((delta <= range) && (p_old != 0))
			{
				cout << p_old << " " << p_old + 2 << "  ";
				cout << p << " " << p+2;								
				cout << "\ttime: " << chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count() << " ms" << endl;				
			}			
			p_old = p;
		}					
	}
}

output:
http://codepad.org/HupTMbTb (0 - 100000)

Double Twin Primes within range 6:

Primes lookup table is produced until 1000000000 (finished)
Twin Primes searched from 999900000 to 1000000000:
999900521 999900523  999900527 999900529        time: 0 ms
999986171 999986173  999986177 999986179        time: 3 ms

Man findet beim max. Abstand 6 (auch bei 8 oder 10) das sich wiederholende Muster: ...1 ...3 ...7 ...9

Erhöht man auf 12, findet man zwei neue Muster, die eigentlich gleich sind:
Muster: ...7 ...9 ..19 ..21
Muster: ...9 ..11 ..21 ..23

Der Abstand zwischen den Double Twin Primes zeigt kein einfach erkennbares Muster (Code: http://codepad.org/ha73fFMk ).

Man findet beim max. Abstand 6 (auch bei 8 oder 10) das sich wiederholende Muster: ...1 ...3 ...7 ...9

Sonst käme ja auch kein Muster in Frage. Bei 3 aufeinanderfolgenden ungeraden Zahlen muss immer eine durch drei teilbar sein.

wichtig hier nur, die Lücke muss durch 15 teilbar sein.