(Apr 15, 2017 07:46 PM)systx Wrote:  I want to create a program that will count to a super high #

(Apr 15, 2017 07:46 PM)systx Wrote:  I want to create a program that will count to a super high #

I have tried the following...

PHP Code


<?php 
import threading
x = 0
def count():
    x += 1
def threads():
    t = threading.Thread(target = x)
    t.start() 


Obviously this fucks up badly so I tried using Queue, but each thread acted as it's own thread not sharing variables :(

I have also tried...

PHP Code


<?php 
import threading
x = 0
lock = threading.Lock()
def count():
    lock.acquire()
    x += 1
    lock.release()
def threads():
    t = threading.Thread(target = x)
    t.start() 


It's like only have one threading running though

So any tips on how to do this would be AWSOME!!! 🤩

(Apr 15, 2017 08:07 PM)Woes Wrote:  Wait what?! Lmao.

Code

x=0
while True:
    x=x+1
    print(x)

(Apr 15, 2017 09:19 PM)Ghosting12 Wrote:  just a bit confused.. if you're on 2.7 and you're lagging try

PHP Code


<?php 
xrange(1, 99999) 


so you're not making a list (atleast I think). python 3+

Code

range(1,9999)

you can also do,

PHP Code


<?php 
range(9991,9999) 


or

Code

range(1, 200, 5) # counts by 5

(Apr 15, 2017 09:26 PM)systx Wrote:  Lol sorry # = Number

---

Yeah I'm using py 3.x
Sadly I need to count up by 1.
It needs to count up to 200000000000 sadly 😟
It would take a couple years to do with one thread :(

(Apr 16, 2017 05:26 AM)obby Wrote:  He is creating a list. (to person who said xrange(int) or range(int) wasnt a list)


Secondly if you want to count to a higher humber just do xrange(999999999999) or something? Why all of that nonsense?
I can't imagine threading, async or multi processing making this faster...

But...

Code

from threading import Thread

theInt = 0

def count():
    global theInt
    while True:
        theInt += 1

for i in xrange(4):
    Thread(target=count).start()

(Apr 15, 2017 10:43 PM)Ghosting12 Wrote:  may I ask why you need to count that?


try this

PHP Code


<?php 
import threading
from itertools import count

counter = count(1)


def counting():
    while True:
        next(counter)
        print(counter)

for i in range(10):
    t = threading.Thread(target=counting).start() 


(Apr 16, 2017 10:01 AM)systx Wrote:  All the nonsense is so I can't count to a high number very quickly. For x in range(99999) is extremely slow as it only uses one thread. Also you don't need theInt globalized
Thanks for the input 🤝

---

Sadly your program doesn't share variables correctly :(
I need it for a project of mine.

(Apr 16, 2017 01:02 PM)Piero-Bird Wrote:  Do you mean something like this?

PHP Code


<?php 
from multiprocessing import Process, RawValue, Lock
import time

class Counter(object):
    def __init__(self, value=0):
        # RawValue because we don't need it to create a Lock:
        self.val = RawValue('i', value)
        self.lock = Lock()

    def increment(self):
        with self.lock:
            self.val.value += 1

    def value(self):
        with self.lock:
            return self.val.value

def inc(counter):
    for i in range(1000):
        counter.increment()

if __name__ == '__main__':
    thread_safe_counter = Counter(0)
    procs = [Process(target=inc, args=(thread_safe_counter,)) for i in range(100)]

    for p in procs: p.start()
    for p in procs: p.join()

    print (thread_safe_counter.value()) 


(Apr 17, 2017 05:03 AM)Mnemosyne Wrote:  Idk whatever you are trying to do but im pretty sure there has some better ways to do.Currently just seems like you are trying to do some useless loop, why?

(Apr 16, 2017 10:01 AM)systx Wrote:  All the nonsense is so I can't count to a high number very quickly. For x in range(99999) is extremely slow as it only uses one thread. Also you don't need theInt globalized
Thanks for the input 🤝

(Apr 18, 2017 11:41 PM)obby Wrote:  Multiprocessing requires locking/releasing due to needing to be concurrent. However 4 processes counting to 1 million without concurrency was faster but defeats the purpose.

In conclusion in my experience no parallelism will count faster than just single process/single thread mainly due to overhead (i think)