Parallel.for Loop - result varies for each click .. why does this happen? - vb.net

Question

Following parallel.for loop uses data of a bitarray which is 300000 bits in length. and the data is fixed not to change. So the produced results "Count_of_Found_Pattern1" must be same no matter how many times I execute the function "check"
But, the issue is the values of "Count_of_Found_Pattern1" & "Count_of_Found_Pattern2" produce different values every time I execute the function "check" .. what have I done wrong?
when I check it using small amount of bits (about 16 bits instead of 300000) it produces good results. But, when the bitarray length is lengthier, it produces a total mess.
For Example:
1st execution --> Count_of_Found_Pattern1 = 150526 , Count_of_Found_Pattern2 = 97855
2nd execution --> Count_of_Found_Pattern1 = 45855 , Count_of_Found_Pattern2 = 187562
Regards!
Private Function check()
Dim Count_of_Found_Pattern1 As Int64 = 0
Dim Count_of_Found_Pattern2 As Int64 = 0
Dim stopwatch As New Stopwatch
stopwatch.Start()
Dim Current_Position1 As Int64 = 0
Dim Current_Position2 As Int64 = 1
Parallel.For(0, lastbitarrayover2, Sub(countbits, loopstate)
If BitArray(Current_Position1) = False And BitArray(Current_Position2) = True Then
Count_of_Found_Pattern1 = Count_of_Found_Pattern1 + 1
End If
If BitArray(Current_Position1) = True And BitArray(Current_Position2) = False Then
Count_of_Found_Pattern1 = Count_of_Found_Pattern1 + 1
End If
If BitArray(Current_Position1) = True And BitArray(Current_Position2) = True Then
Count_of_Found_Pattern2 = Count_of_Found_Pattern2 + 1
End If
If BitArray(Current_Position1) = False And BitArray(Current_Position2) = False Then
Count_of_Found_Pattern2 = Count_of_Found_Pattern2 + 1
End If
Current_Position1 = Current_Position1 + 2
Current -Position2 = Current_Position2 + 2
Numer_of_Completed_Iterations = Numer_of_Completed_Iterations + 1
End Sub)
Numer_of_Completed_Iterations = 0 'reset counter to 0
stopwatch.Stop()
TextBox1.Text = stopwatch.Elapsed.ToString
End Function

Answer 1

When you increment Count_of_Found_Pattern1 (or Pattern2), first the value is read, then it is incremented, then it assigned. But the thread that is executing can change during those three steps.
Thread 1: Read Count_of_Found_Pattern1
Thread 2: Read Count_of_Found_Pattern1
Thread 2: Increment
Thread 2: Write to Count_of_Found_Pattern1
...
Thread 1: Increment its old value
Thread 1: Write to Count_of_Found_Pattern1
Now Count_of_Found_Pattern1 is wrong. And if Thread 2 had control of execution for more than just one iteration, it could be very wrong.
Consider doing as much as possible within PLINQ, avoiding any mutation of global state until all the threads have joined back up. The following code assumes you're interested in comparing adjacent entries in BitArray:
Dim counts = Enumerable.
Range(0, lastbitarrayover2 / 2).Select(Function(i) i * 2).
AsParallel().
Aggregate(
Function()
' We're using an object of anonymous type to hold
' the results of the calculation so far.
' Each thread calls this function, so each thread
' gets its own object for holding intermediate results
Return New With {.Pattern1 = 0, .Pattern2 = 0, .Iterations = 0}
End Function,
Function(accumulator, i)
' accumulator is this thread's intermediate-result-holder.
' i is one of the even numbers from our big set of even numbers.
' Each thread will call this function many times, building up its own accumulator object
' the four conditionals from your code reduce to this If block
If (BitArray(i) = BitArray(i + 1)) Then
accumulator.Pattern2 += 1
Else
accumulator.Pattern1 += 1
End If
accumulator.Iterations += 1
Return accumulator
End Function,
Function(acc1, acc2)
' Once each thread has built up its own accumulator object,
' this function makes a new accumulator object that
' combines the results from two threads.
' This is called repeatedly until all the threads' results
' have been combined.
Return New With {
.Pattern1 = acc1.Pattern1 + acc2.Pattern1,
.Pattern2 = acc1.Pattern2 + acc2.Pattern2,
.Iterations = acc1.Iterations + acc2.Iterations}
End Function,
Function(acc)
' The last function here is supposed to take the combined results
' and turn them into what you ultimately want to use.
' Since the combined results are already in the form we want,
' we'll just use the "identity" function here: it returns its
' argument unchanged
Return acc
End Function)
Count_of_Found_Pattern1 = counts.Pattern1
Count_of_Found_Pattern2 = counts.Pattern2
Number_of_Completed_Iterations = counts.Iterations
This might seem like a lot, but it's really not too bad. The main thing is that we are giving each thread its own set of variables to work with; that way we don't have to worry about the problems I outlined at the top of my answer. Then, we combine the work done by each thread at the end.

Answer 2

Have you tried System.Threading.Interlocked.Increment to make this thread safe? For example:
If BitArray(Current_Position1) = False And BitArray(Current_Position2) = True Then
Interlocked.Increment(Count_of_Found_Pattern1)
End If