That question may appear strange.

But every time I made PHP projects in the past, I encountered this sort of bad experience:

Scripts cancel running after 10 seconds. This results in very bad database inconsistencies (bad example for an deleting loop: User is about to delete an photo album. Album object gets deleted from database, and then half way down of deleting the photos the script gets killed right where it is, and 10.000 photos are left with no reference).

It's not transaction-safe. I've never found a way to do something securely, to ensure it's done. If script gets killed, it gets killed. Right in the middle of a loop. It gets just killed. That never happened on tomcat with java. Java runs and runs and runs, if it takes long.

Lot's of newsletter-scripts try to come around that problem by splitting the job up into a lot of packages, i.e. sending 100 at a time, then relading the page (oh man, really stupid), doing the next one, and so on. Most often something hangs or script will take longer than 10 seconds, and your platform is crippled up.

But then, I hear that very big projects use PHP like studivz (the german facebook clone, actually the biggest german website). So there is a tiny light of hope that this bad behavior just comes from unprofessional hosting companies who just kill php scripts because their servers are so bad. What's the truth about this? Can it be configured in such a way, that scripts never get killed because they take a little longer?

No correct solution


Is PHP suitable for very large projects?

Whenever I see a question like that, I get a bit uneasy. What does very large mean? What may be large to you, may be small to me or vice versa. And that is even assuming that we use the same metric. Are you measuring time to build the project, complete life-cycle of the project, money that are involved, number of people using it, number of developers to build/maintain it, etc. etc.

That said, the problems you're describing sounds like you don't know your technology good enough. That would be a problem for you regardless of which technology you picked. For example, use database transactions to ensure atomicity. And use asynchronous offline jobs to process long running tasks (Such as dispatching a mailing list).

A lot if the bad behaviour is covered in good frameworks like the Zend Framework. Anything that takes longer the 10 seconds is really messed up but you can always raise the execution time with

A lot of big sites are writen in PHP: Facebook, Wikipedia, StudiVZ, etc.. a lot of the things you are talking about are just configuration things maybe you should look into that?

Are you looking for set_time_limit() and ignore_user_abort()?

Performance is not a feature you can just throw in after most of the site is done. You have to design the site for heavy load.

If a database task is normally involving 10K rows, you should be prepared not just the execution time issues, but other maintenance questions.

  • Worst case: make a consistency tool to check and fix those errors.
  • Better: instead of phisically delete the images, just flag them and let background services to take care of the expensive maneuvers.
  • Best: you can utilize a job queue service and add this job to the queue.

If you do need to do transactions in php, you can just do:


/// do your queries here


The commit command will just complete the transaction.

If any errors occur, you can just rollback with:


Edit: Note this will only work if you are using a database that supports transactions, such as InnoDB

You can configure how much time is allowed for executing a script, either in the php.ini setting or via ini_set/set_time_limit

Instead of studivz (the German Facebook clone), you could look at the actual Facebook which is entirely PHP. Or Digg. Or many Yahoo sites. Or many, many others.

ignore_user_abort is probably what you're looking for, but you could also add another layer in terms of scheduled maintenance jobs. They basically run on a specified interval and do various things to make sure your data/filesystem are in a state that you want... deleting old/unlinked files is just one of many things you can do.

For these large loops like deleting photo albums or sending 1000's of emails your looking for ignore_user_abort and set_time_limit.
Something like this:

ignore_user_abort(true); //users leaves webpage will not kill script
set_time_limit(0); //script can take as long as it wants

Be carefull however that this could potentially run the script forever:

ignore_user_abort(true); //users leaves webpage will not kill script
set_time_limit(0); //script can take as long as it wants

That script will never die, unless you restart your server.

Therefore it is best to never set the time_limit the 0.

Technically no programming language is transaction safe, it's the database that needs to be transaction safe. So if the script/code running dies or disconnects, for whatever reason, the transaction will be rolled back.

Putting queries in a loop is a very bad idea unless it is specifically design to be running in batches and breaking a much larger set into smaller pieces. Adjusting PHP timers and limits is generally a stop gap solution, you are still dependent on the client browser if using the web to kick off a script.

If I have a long process that needs to be kicked off by a browser, I "disconnect" the process from the browser and web server so control is returned to the user while the script runs. PHP scripts run from the command line can run for hours if you want. You can then use AJAX, or reload the page, to check on the progress of the long running script.

There are security concern with this code, but to "disconnect" a process from PHP running under something like Apache:

exec("nohup /usr/bin/php -f /path/to/script.php > /dev/null 2>&1 &");

But that really has nothing to do with PHP being suitable for large projects or being transaction safe. PHP can be used for large projects, but since by default there is no code that remains "resident" between hits, it can get slow if not designed right. Also, since there is no namespace support, you want to plan ahead if you have a large development team.

It's fine for a Java based system to take a few minutes to startup, initialize and load all the default objects. But this is unacceptable with PHP. PHP will take more planning for larger systems. The question is, when does the time saved in using PHP get wasted by the additional planning time required for a large system?

The reason you most likely experienced bad database consistencies in the past is because you were using the MyISAM engine for mysql (which DOES NOT support transactions). Use InnoDB instead, it supports transactions and performs row level locking. Or use postgreSQL.

Many, many software sites are made in PHP. However, you will not hear about millions of web pages made in PHP that do not exist anymore because they were abandoned. Those pages may have burned all company money for dealing with PHP mess, or maybe they bankrupted because their soft was so crappy that customer did not want it… PHP seems good at the startup, but it does not scale very well. Yes, there are many huge web sites made in PHP, but they are rather exceptions, than a norm.

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow
scroll top